home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / src / get.c < prev    next >
C/C++ Source or Header  |  1999-02-04  |  114KB  |  3,606 lines
  1. /* $Id: get.c,v 3.16 1998/10/01 02:51:39 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.1
  6.  * Copyright (C) 1995-1998  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: get.c,v $
  26.  * Revision 3.16  1998/10/01 02:51:39  brianp
  27.  * added GL_MAX_3D_TEXTURE_SIZE support to glGet*()
  28.  *
  29.  * Revision 3.15  1998/07/29 04:09:33  brianp
  30.  * getting polygon stipple on/off state was broken
  31.  *
  32.  * Revision 3.14  1998/07/18 03:32:54  brianp
  33.  * added GL_SELECTION_BUFFER_SIZE GL_SELECTION_BUFFER_POINTER cases
  34.  *
  35.  * Revision 3.13  1998/06/19 03:10:50  brianp
  36.  * glGet(MODELVIEW/PROJECTION/MATRIX_STACK_DEPTH) was off by one
  37.  *
  38.  * Revision 3.12  1998/06/07 22:18:52  brianp
  39.  * implemented GL_EXT_multitexture extension
  40.  *
  41.  * Revision 3.11  1998/05/31 23:50:36  brianp
  42.  * cleaned up a few Solaris compiler warnings
  43.  *
  44.  * Revision 3.10  1998/04/01 02:59:42  brianp
  45.  * updated for v0.24 of 3Dfx/Glide driver
  46.  *
  47.  * Revision 3.9  1998/03/27 03:37:40  brianp
  48.  * fixed G++ warnings
  49.  *
  50.  * Revision 3.8  1998/02/21 01:02:03  brianp
  51.  * query driver for max number of textures
  52.  *
  53.  * Revision 3.7  1998/02/20 04:50:44  brianp
  54.  * implemented GL_SGIS_multitexture
  55.  *
  56.  * Revision 3.6  1998/02/13 03:23:04  brianp
  57.  * AlphaRef is now a GLubyte
  58.  *
  59.  * Revision 3.5  1998/02/08 20:19:41  brianp
  60.  * ColorMask is now GLubyte[4] instead of GLuint
  61.  *
  62.  * Revision 3.4  1998/02/07 14:43:46  brianp
  63.  * get GL_MAX_TEXTURE_SIZE now queries device driver
  64.  *
  65.  * Revision 3.3  1998/02/04 05:00:07  brianp
  66.  * added a few casts for Amiga StormC compiler
  67.  *
  68.  * Revision 3.2  1998/02/02 03:09:34  brianp
  69.  * added GL_LIGHT_MODEL_COLOR_CONTROL (separate specular color interpolation)
  70.  *
  71.  * Revision 3.1  1998/02/01 20:05:10  brianp
  72.  * added glDrawRangeElements()
  73.  *
  74.  * Revision 3.0  1998/01/31 20:53:22  brianp
  75.  * initial rev
  76.  *
  77.  */
  78.  
  79.  
  80. #ifdef PC_HEADER
  81. #include "all.h"
  82. #else
  83. #include <assert.h>
  84. #include <string.h>
  85. #include "context.h"
  86. #include "get.h"
  87. #include "macros.h"
  88. #include "types.h"
  89. #include "vb.h"
  90. #endif
  91.  
  92.  
  93.  
  94. #define FLOAT_TO_BOOL(X)    ( (X)==0.0F ? GL_FALSE : GL_TRUE )
  95. #define INT_TO_BOOL(I)        ( (I)==0 ? GL_FALSE : GL_TRUE )
  96. #define ENUM_TO_BOOL(E)        ( (E)==0 ? GL_FALSE : GL_TRUE )
  97.  
  98. #ifdef SPECIALCAST
  99. /* Needed for an Amiga compiler */
  100. #define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X))
  101. #define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X))
  102. #else
  103. /* all other compilers */
  104. #define ENUM_TO_FLOAT(X) ((GLfloat)(X))
  105. #define ENUM_TO_DOUBLE(X) ((GLdouble)(X))
  106. #endif
  107.  
  108.  
  109.  
  110. /*
  111.  * Return max number of simultaneous textures.
  112.  */
  113. static GLint max_textures(const GLcontext *ctx)
  114. {
  115.    if (ctx->Driver.GetParameteri) {
  116.       GLint maxSets = (*ctx->Driver.GetParameteri)(ctx, DD_MAX_TEXTURES);
  117.       assert(maxSets >= 1 && maxSets <= MAX_TEX_SETS);
  118.       return maxSets;
  119.    }
  120.    else {
  121.       return MAX_TEX_SETS;
  122.    }
  123. }
  124.  
  125.  
  126.  
  127. /*
  128.  * Return max texture size.
  129.  */
  130. static GLint max_texture_size(const GLcontext *ctx)
  131. {
  132.    if (ctx->Driver.GetParameteri)
  133.       return (ctx->Driver.GetParameteri)(ctx, DD_MAX_TEXTURE_SIZE);
  134.    else
  135.       return MAX_TEXTURE_SIZE;
  136. }
  137.  
  138.  
  139.  
  140. void gl_GetBooleanv( GLcontext *ctx, GLenum pname, GLboolean *params )
  141. {
  142.    GLuint i;
  143.    GLuint texSet = ctx->Texture.CurrentSet;
  144.    GLuint texTransformSet = ctx->Texture.CurrentTransformSet;
  145.    const struct gl_texture_set *textureSet = &ctx->Texture.Set[texSet];
  146.  
  147.    if (INSIDE_BEGIN_END(ctx)) {
  148.       gl_error( ctx, GL_INVALID_OPERATION, "glGetBooleanv" );
  149.       return;
  150.    }
  151.  
  152.    switch (pname) {
  153.       case GL_ACCUM_RED_BITS:
  154.       case GL_ACCUM_GREEN_BITS:
  155.       case GL_ACCUM_BLUE_BITS:
  156.       case GL_ACCUM_ALPHA_BITS:
  157.          *params = INT_TO_BOOL(ctx->Visual->AccumBits);
  158.          break;
  159.       case GL_ACCUM_CLEAR_VALUE:
  160.          params[0] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[0]);
  161.          params[1] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[1]);
  162.          params[2] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[2]);
  163.          params[3] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[3]);
  164.          break;
  165.       case GL_ALPHA_BIAS:
  166.          *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaBias);
  167.          break;
  168.       case GL_ALPHA_BITS:
  169.          *params = INT_TO_BOOL(ctx->Visual->AlphaBits);
  170.          break;
  171.       case GL_ALPHA_SCALE:
  172.          *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaScale);
  173.          break;
  174.       case GL_ALPHA_TEST:
  175.          *params = ctx->Color.AlphaEnabled;
  176.          break;
  177.       case GL_ALPHA_TEST_FUNC:
  178.          *params = ENUM_TO_BOOL(ctx->Color.AlphaFunc);
  179.          break;
  180.       case GL_ALPHA_TEST_REF:
  181.          *params = FLOAT_TO_BOOL((GLfloat) ctx->Color.AlphaRef / 255.0);
  182.          break;
  183.       case GL_ATTRIB_STACK_DEPTH:
  184.          *params = INT_TO_BOOL(ctx->AttribStackDepth);
  185.          break;
  186.       case GL_AUTO_NORMAL:
  187.          *params = ctx->Eval.AutoNormal;
  188.          break;
  189.       case GL_AUX_BUFFERS:
  190.          *params = (NUM_AUX_BUFFERS) ? GL_TRUE : GL_FALSE;
  191.          break;
  192.       case GL_BLEND:
  193.          *params = ctx->Color.BlendEnabled;
  194.          break;
  195.       case GL_BLEND_DST:
  196.          *params = ENUM_TO_BOOL(ctx->Color.BlendDst);
  197.          break;
  198.       case GL_BLEND_SRC:
  199.          *params = ENUM_TO_BOOL(ctx->Color.BlendSrc);
  200.          break;
  201.       case GL_BLEND_EQUATION_EXT:
  202.      *params = ENUM_TO_BOOL( ctx->Color.BlendEquation );
  203.      break;
  204.       case GL_BLEND_COLOR_EXT:
  205.      params[0] = FLOAT_TO_BOOL( ctx->Color.BlendColor[0] );
  206.      params[1] = FLOAT_TO_BOOL( ctx->Color.BlendColor[1] );
  207.      params[2] = FLOAT_TO_BOOL( ctx->Color.BlendColor[2] );
  208.      params[3] = FLOAT_TO_BOOL( ctx->Color.BlendColor[3] );
  209.      break;
  210.       case GL_BLUE_BIAS:
  211.          *params = FLOAT_TO_BOOL(ctx->Pixel.BlueBias);
  212.          break;
  213.       case GL_BLUE_BITS:
  214.          *params = INT_TO_BOOL( ctx->Visual->BlueBits );
  215.          break;
  216.       case GL_BLUE_SCALE:
  217.          *params = FLOAT_TO_BOOL(ctx->Pixel.BlueScale);
  218.          break;
  219.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  220.          *params = INT_TO_BOOL(ctx->ClientAttribStackDepth);
  221.          break;
  222.       case GL_CLIP_PLANE0:
  223.       case GL_CLIP_PLANE1:
  224.       case GL_CLIP_PLANE2:
  225.       case GL_CLIP_PLANE3:
  226.       case GL_CLIP_PLANE4:
  227.       case GL_CLIP_PLANE5:
  228.          *params = ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  229.          break;
  230.       case GL_COLOR_CLEAR_VALUE:
  231.          params[0] = FLOAT_TO_BOOL(ctx->Color.ClearColor[0]);
  232.          params[1] = FLOAT_TO_BOOL(ctx->Color.ClearColor[1]);
  233.          params[2] = FLOAT_TO_BOOL(ctx->Color.ClearColor[2]);
  234.          params[3] = FLOAT_TO_BOOL(ctx->Color.ClearColor[3]);
  235.          break;
  236.       case GL_COLOR_MATERIAL:
  237.          *params = ctx->Light.ColorMaterialEnabled;
  238.          break;
  239.       case GL_COLOR_MATERIAL_FACE:
  240.          *params = ENUM_TO_BOOL(ctx->Light.ColorMaterialFace);
  241.          break;
  242.       case GL_COLOR_MATERIAL_PARAMETER:
  243.          *params = ENUM_TO_BOOL(ctx->Light.ColorMaterialMode);
  244.          break;
  245.       case GL_COLOR_WRITEMASK:
  246.          params[0] = ctx->Color.ColorMask[RCOMP] ? GL_TRUE : GL_FALSE;
  247.          params[1] = ctx->Color.ColorMask[GCOMP] ? GL_TRUE : GL_FALSE;
  248.          params[2] = ctx->Color.ColorMask[BCOMP] ? GL_TRUE : GL_FALSE;
  249.          params[3] = ctx->Color.ColorMask[ACOMP] ? GL_TRUE : GL_FALSE;
  250.          break;
  251.       case GL_CULL_FACE:
  252.          *params = ctx->Polygon.CullFlag;
  253.          break;
  254.       case GL_CULL_FACE_MODE:
  255.          *params = ENUM_TO_BOOL(ctx->Polygon.CullFaceMode);
  256.          break;
  257.       case GL_CURRENT_COLOR:
  258.          params[0] = INT_TO_BOOL(ctx->Current.ByteColor[0]);
  259.          params[1] = INT_TO_BOOL(ctx->Current.ByteColor[1]);
  260.          params[2] = INT_TO_BOOL(ctx->Current.ByteColor[2]);
  261.          params[3] = INT_TO_BOOL(ctx->Current.ByteColor[3]);
  262.          break;
  263.       case GL_CURRENT_INDEX:
  264.          *params = INT_TO_BOOL(ctx->Current.Index);
  265.          break;
  266.       case GL_CURRENT_NORMAL:
  267.          params[0] = FLOAT_TO_BOOL(ctx->Current.Normal[0]);
  268.          params[1] = FLOAT_TO_BOOL(ctx->Current.Normal[1]);
  269.          params[2] = FLOAT_TO_BOOL(ctx->Current.Normal[2]);
  270.          break;
  271.       case GL_CURRENT_RASTER_COLOR:
  272.      params[0] = FLOAT_TO_BOOL(ctx->Current.RasterColor[0]);
  273.      params[1] = FLOAT_TO_BOOL(ctx->Current.RasterColor[1]);
  274.      params[2] = FLOAT_TO_BOOL(ctx->Current.RasterColor[2]);
  275.      params[3] = FLOAT_TO_BOOL(ctx->Current.RasterColor[3]);
  276.      break;
  277.       case GL_CURRENT_RASTER_DISTANCE:
  278.      *params = FLOAT_TO_BOOL(ctx->Current.RasterDistance);
  279.      break;
  280.       case GL_CURRENT_RASTER_INDEX:
  281.      *params = FLOAT_TO_BOOL(ctx->Current.RasterIndex);
  282.      break;
  283.       case GL_CURRENT_RASTER_POSITION:
  284.      params[0] = FLOAT_TO_BOOL(ctx->Current.RasterPos[0]);
  285.      params[1] = FLOAT_TO_BOOL(ctx->Current.RasterPos[1]);
  286.      params[2] = FLOAT_TO_BOOL(ctx->Current.RasterPos[2]);
  287.      params[3] = FLOAT_TO_BOOL(ctx->Current.RasterPos[3]);
  288.      break;
  289.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  290.          params[0] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformSet][0]);
  291.          params[1] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformSet][1]);
  292.          params[2] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformSet][2]);
  293.          params[3] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformSet][3]);
  294.      break;
  295.       case GL_CURRENT_RASTER_POSITION_VALID:
  296.          *params = ctx->Current.RasterPosValid;
  297.      break;
  298.       case GL_CURRENT_TEXTURE_COORDS:
  299.          params[0] = FLOAT_TO_BOOL(ctx->Current.MultiTexCoord[texTransformSet][0]);
  300.          params[1] = FLOAT_TO_BOOL(ctx->Current.MultiTexCoord[texTransformSet][1]);
  301.          params[2] = FLOAT_TO_BOOL(ctx->Current.MultiTexCoord[texTransformSet][2]);
  302.          params[3] = FLOAT_TO_BOOL(ctx->Current.MultiTexCoord[texTransformSet][3]);
  303.      break;
  304.       case GL_DEPTH_BIAS:
  305.          *params = FLOAT_TO_BOOL(ctx->Pixel.DepthBias);
  306.      break;
  307.       case GL_DEPTH_BITS:
  308.      *params = INT_TO_BOOL(ctx->Visual->DepthBits);
  309.      break;
  310.       case GL_DEPTH_CLEAR_VALUE:
  311.          *params = FLOAT_TO_BOOL(ctx->Depth.Clear);
  312.      break;
  313.       case GL_DEPTH_FUNC:
  314.          *params = ENUM_TO_BOOL(ctx->Depth.Func);
  315.      break;
  316.       case GL_DEPTH_RANGE:
  317.          params[0] = FLOAT_TO_BOOL(ctx->Viewport.Near);
  318.          params[1] = FLOAT_TO_BOOL(ctx->Viewport.Far);
  319.      break;
  320.       case GL_DEPTH_SCALE:
  321.          *params = FLOAT_TO_BOOL(ctx->Pixel.DepthScale);
  322.      break;
  323.       case GL_DEPTH_TEST:
  324.          *params = ctx->Depth.Test;
  325.      break;
  326.       case GL_DEPTH_WRITEMASK:
  327.      *params = ctx->Depth.Mask;
  328.      break;
  329.       case GL_DITHER:
  330.      *params = ctx->Color.DitherFlag;
  331.      break;
  332.       case GL_DOUBLEBUFFER:
  333.      *params = ctx->Visual->DBflag;
  334.      break;
  335.       case GL_DRAW_BUFFER:
  336.      *params = ENUM_TO_BOOL(ctx->Color.DrawBuffer);
  337.      break;
  338.       case GL_EDGE_FLAG:
  339.      *params = ctx->Current.EdgeFlag;
  340.      break;
  341.       case GL_FEEDBACK_BUFFER_SIZE:
  342.          /* TODO: is this right?  Or, return number of entries in buffer? */
  343.          *params = INT_TO_BOOL(ctx->Feedback.BufferSize);
  344.          break;
  345.       case GL_FEEDBACK_BUFFER_TYPE:
  346.          *params = INT_TO_BOOL(ctx->Feedback.Type);
  347.          break;
  348.       case GL_FOG:
  349.      *params = ctx->Fog.Enabled;
  350.      break;
  351.       case GL_FOG_COLOR:
  352.          params[0] = FLOAT_TO_BOOL(ctx->Fog.Color[0]);
  353.          params[1] = FLOAT_TO_BOOL(ctx->Fog.Color[1]);
  354.          params[2] = FLOAT_TO_BOOL(ctx->Fog.Color[2]);
  355.          params[3] = FLOAT_TO_BOOL(ctx->Fog.Color[3]);
  356.      break;
  357.       case GL_FOG_DENSITY:
  358.          *params = FLOAT_TO_BOOL(ctx->Fog.Density);
  359.      break;
  360.       case GL_FOG_END:
  361.          *params = FLOAT_TO_BOOL(ctx->Fog.End);
  362.      break;
  363.       case GL_FOG_HINT:
  364.      *params = ENUM_TO_BOOL(ctx->Hint.Fog);
  365.      break;
  366.       case GL_FOG_INDEX:
  367.      *params = FLOAT_TO_BOOL(ctx->Fog.Index);
  368.      break;
  369.       case GL_FOG_MODE:
  370.      *params = ENUM_TO_BOOL(ctx->Fog.Mode);
  371.      break;
  372.       case GL_FOG_START:
  373.          *params = FLOAT_TO_BOOL(ctx->Fog.End);
  374.      break;
  375.       case GL_FRONT_FACE:
  376.      *params = ENUM_TO_BOOL(ctx->Polygon.FrontFace);
  377.      break;
  378.       case GL_GREEN_BIAS:
  379.          *params = FLOAT_TO_BOOL(ctx->Pixel.GreenBias);
  380.      break;
  381.       case GL_GREEN_BITS:
  382.          *params = INT_TO_BOOL( ctx->Visual->GreenBits );
  383.      break;
  384.       case GL_GREEN_SCALE:
  385.          *params = FLOAT_TO_BOOL(ctx->Pixel.GreenScale);
  386.      break;
  387.       case GL_INDEX_BITS:
  388.          *params = INT_TO_BOOL( ctx->Visual->IndexBits );
  389.      break;
  390.       case GL_INDEX_CLEAR_VALUE:
  391.      *params = INT_TO_BOOL(ctx->Color.ClearIndex);
  392.      break;
  393.       case GL_INDEX_MODE:
  394.      *params = ctx->Visual->RGBAflag ? GL_FALSE : GL_TRUE;
  395.      break;
  396.       case GL_INDEX_OFFSET:
  397.      *params = INT_TO_BOOL(ctx->Pixel.IndexOffset);
  398.      break;
  399.       case GL_INDEX_SHIFT:
  400.      *params = INT_TO_BOOL(ctx->Pixel.IndexShift);
  401.      break;
  402.       case GL_INDEX_WRITEMASK:
  403.      *params = INT_TO_BOOL(ctx->Color.IndexMask);
  404.      break;
  405.       case GL_LIGHT0:
  406.       case GL_LIGHT1:
  407.       case GL_LIGHT2:
  408.       case GL_LIGHT3:
  409.       case GL_LIGHT4:
  410.       case GL_LIGHT5:
  411.       case GL_LIGHT6:
  412.       case GL_LIGHT7:
  413.      *params = ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  414.      break;
  415.       case GL_LIGHTING:
  416.      *params = ctx->Light.Enabled;
  417.      break;
  418.       case GL_LIGHT_MODEL_AMBIENT:
  419.      params[0] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[0]);
  420.      params[1] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[1]);
  421.      params[2] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[2]);
  422.      params[3] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[3]);
  423.      break;
  424.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  425.          params[0] = ENUM_TO_BOOL(ctx->Light.Model.ColorControl);
  426.          break;
  427.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  428.      *params = ctx->Light.Model.LocalViewer;
  429.      break;
  430.       case GL_LIGHT_MODEL_TWO_SIDE:
  431.      *params = ctx->Light.Model.TwoSide;
  432.      break;
  433.       case GL_LINE_SMOOTH:
  434.      *params = ctx->Line.SmoothFlag;
  435.      break;
  436.       case GL_LINE_SMOOTH_HINT:
  437.      *params = ENUM_TO_BOOL(ctx->Hint.LineSmooth);
  438.      break;
  439.       case GL_LINE_STIPPLE:
  440.      *params = ctx->Line.StippleFlag;
  441.      break;
  442.       case GL_LINE_STIPPLE_PATTERN:
  443.      *params = INT_TO_BOOL(ctx->Line.StipplePattern);
  444.      break;
  445.       case GL_LINE_STIPPLE_REPEAT:
  446.      *params = INT_TO_BOOL(ctx->Line.StippleFactor);
  447.      break;
  448.       case GL_LINE_WIDTH:
  449.      *params = FLOAT_TO_BOOL(ctx->Line.Width);
  450.      break;
  451.       case GL_LINE_WIDTH_GRANULARITY:
  452.      *params = FLOAT_TO_BOOL(LINE_WIDTH_GRANULARITY);
  453.      break;
  454.       case GL_LINE_WIDTH_RANGE:
  455.      params[0] = FLOAT_TO_BOOL(MIN_LINE_WIDTH);
  456.      params[1] = FLOAT_TO_BOOL(MAX_LINE_WIDTH);
  457.      break;
  458.       case GL_LIST_BASE:
  459.      *params = INT_TO_BOOL(ctx->List.ListBase);
  460.      break;
  461.       case GL_LIST_INDEX:
  462.      *params = INT_TO_BOOL( ctx->CurrentListNum );
  463.      break;
  464.       case GL_LIST_MODE:
  465.      *params = ENUM_TO_BOOL( ctx->ExecuteFlag
  466.                   ? GL_COMPILE_AND_EXECUTE : GL_COMPILE );
  467.      break;
  468.       case GL_INDEX_LOGIC_OP:
  469.      *params = ctx->Color.IndexLogicOpEnabled;
  470.      break;
  471.       case GL_COLOR_LOGIC_OP:
  472.      *params = ctx->Color.ColorLogicOpEnabled;
  473.      break;
  474.       case GL_LOGIC_OP_MODE:
  475.      *params = ENUM_TO_BOOL(ctx->Color.LogicOp);
  476.      break;
  477.       case GL_MAP1_COLOR_4:
  478.      *params = ctx->Eval.Map1Color4;
  479.      break;
  480.       case GL_MAP1_GRID_DOMAIN:
  481.      params[0] = FLOAT_TO_BOOL(ctx->Eval.MapGrid1u1);
  482.      params[1] = FLOAT_TO_BOOL(ctx->Eval.MapGrid1u2);
  483.      break;
  484.       case GL_MAP1_GRID_SEGMENTS:
  485.      *params = INT_TO_BOOL(ctx->Eval.MapGrid1un);
  486.      break;
  487.       case GL_MAP1_INDEX:
  488.      *params = ctx->Eval.Map1Index;
  489.      break;
  490.       case GL_MAP1_NORMAL:
  491.      *params = ctx->Eval.Map1Normal;
  492.      break;
  493.       case GL_MAP1_TEXTURE_COORD_1:
  494.      *params = ctx->Eval.Map1TextureCoord1;
  495.      break;
  496.       case GL_MAP1_TEXTURE_COORD_2:
  497.      *params = ctx->Eval.Map1TextureCoord2;
  498.      break;
  499.       case GL_MAP1_TEXTURE_COORD_3:
  500.      *params = ctx->Eval.Map1TextureCoord3;
  501.      break;
  502.       case GL_MAP1_TEXTURE_COORD_4:
  503.      *params = ctx->Eval.Map1TextureCoord4;
  504.      break;
  505.       case GL_MAP1_VERTEX_3:
  506.      *params = ctx->Eval.Map1Vertex3;
  507.      break;
  508.       case GL_MAP1_VERTEX_4:
  509.      *params = ctx->Eval.Map1Vertex4;
  510.      break;
  511.       case GL_MAP2_COLOR_4:
  512.      *params = ctx->Eval.Map2Color4;
  513.      break;
  514.       case GL_MAP2_GRID_DOMAIN:
  515.      params[0] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2u1);
  516.      params[1] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2u2);
  517.      params[2] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2v1);
  518.      params[3] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2v2);
  519.      break;
  520.       case GL_MAP2_GRID_SEGMENTS:
  521.      params[0] = INT_TO_BOOL(ctx->Eval.MapGrid2un);
  522.      params[1] = INT_TO_BOOL(ctx->Eval.MapGrid2vn);
  523.      break;
  524.       case GL_MAP2_INDEX:
  525.      *params = ctx->Eval.Map2Index;
  526.      break;
  527.       case GL_MAP2_NORMAL:
  528.      *params = ctx->Eval.Map2Normal;
  529.      break;
  530.       case GL_MAP2_TEXTURE_COORD_1:
  531.      *params = ctx->Eval.Map2TextureCoord1;
  532.      break;
  533.       case GL_MAP2_TEXTURE_COORD_2:
  534.      *params = ctx->Eval.Map2TextureCoord2;
  535.      break;
  536.       case GL_MAP2_TEXTURE_COORD_3:
  537.      *params = ctx->Eval.Map2TextureCoord3;
  538.      break;
  539.       case GL_MAP2_TEXTURE_COORD_4:
  540.      *params = ctx->Eval.Map2TextureCoord4;
  541.      break;
  542.       case GL_MAP2_VERTEX_3:
  543.      *params = ctx->Eval.Map2Vertex3;
  544.      break;
  545.       case GL_MAP2_VERTEX_4:
  546.      *params = ctx->Eval.Map2Vertex4;
  547.      break;
  548.       case GL_MAP_COLOR:
  549.      *params = ctx->Pixel.MapColorFlag;
  550.      break;
  551.       case GL_MAP_STENCIL:
  552.      *params = ctx->Pixel.MapStencilFlag;
  553.      break;
  554.       case GL_MATRIX_MODE:
  555.      *params = ENUM_TO_BOOL( ctx->Transform.MatrixMode );
  556.      break;
  557.       case GL_MAX_ATTRIB_STACK_DEPTH:
  558.      *params = INT_TO_BOOL(MAX_ATTRIB_STACK_DEPTH);
  559.      break;
  560.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  561.          *params = INT_TO_BOOL( MAX_CLIENT_ATTRIB_STACK_DEPTH);
  562.          break;
  563.       case GL_MAX_CLIP_PLANES:
  564.      *params = INT_TO_BOOL(MAX_CLIP_PLANES);
  565.      break;
  566.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  567.          *params = INT_TO_BOOL(VB_MAX);
  568.          break;
  569.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  570.          *params = INT_TO_BOOL(VB_MAX);
  571.          break;
  572.       case GL_MAX_EVAL_ORDER:
  573.      *params = INT_TO_BOOL(MAX_EVAL_ORDER);
  574.      break;
  575.       case GL_MAX_LIGHTS:
  576.      *params = INT_TO_BOOL(MAX_LIGHTS);
  577.      break;
  578.       case GL_MAX_LIST_NESTING:
  579.      *params = INT_TO_BOOL(MAX_LIST_NESTING);
  580.      break;
  581.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  582.      *params = INT_TO_BOOL(MAX_MODELVIEW_STACK_DEPTH);
  583.      break;
  584.       case GL_MAX_NAME_STACK_DEPTH:
  585.      *params = INT_TO_BOOL(MAX_NAME_STACK_DEPTH);
  586.      break;
  587.       case GL_MAX_PIXEL_MAP_TABLE:
  588.      *params = INT_TO_BOOL(MAX_PIXEL_MAP_TABLE);
  589.      break;
  590.       case GL_MAX_PROJECTION_STACK_DEPTH:
  591.      *params = INT_TO_BOOL(MAX_PROJECTION_STACK_DEPTH);
  592.      break;
  593.       case GL_MAX_TEXTURE_SIZE:
  594.       case GL_MAX_3D_TEXTURE_SIZE:
  595.          *params = INT_TO_BOOL(max_texture_size(ctx));
  596.      break;
  597.       case GL_MAX_TEXTURE_STACK_DEPTH:
  598.      *params = INT_TO_BOOL(MAX_TEXTURE_STACK_DEPTH);
  599.      break;
  600.       case GL_MAX_VIEWPORT_DIMS:
  601.      params[0] = INT_TO_BOOL(MAX_WIDTH);
  602.      params[1] = INT_TO_BOOL(MAX_HEIGHT);
  603.      break;
  604.       case GL_MODELVIEW_MATRIX:
  605.      for (i=0;i<16;i++) {
  606.         params[i] = FLOAT_TO_BOOL(ctx->ModelViewMatrix[i]);
  607.      }
  608.      break;
  609.       case GL_MODELVIEW_STACK_DEPTH:
  610.      *params = INT_TO_BOOL(ctx->ModelViewStackDepth + 1);
  611.      break;
  612.       case GL_NAME_STACK_DEPTH:
  613.      *params = INT_TO_BOOL(ctx->Select.NameStackDepth);
  614.      break;
  615.       case GL_NORMALIZE:
  616.      *params = ctx->Transform.Normalize;
  617.      break;
  618.       case GL_PACK_ALIGNMENT:
  619.      *params = INT_TO_BOOL(ctx->Pack.Alignment);
  620.      break;
  621.       case GL_PACK_LSB_FIRST:
  622.      *params = ctx->Pack.LsbFirst;
  623.      break;
  624.       case GL_PACK_ROW_LENGTH:
  625.      *params = INT_TO_BOOL(ctx->Pack.RowLength);
  626.      break;
  627.       case GL_PACK_SKIP_PIXELS:
  628.      *params = INT_TO_BOOL(ctx->Pack.SkipPixels);
  629.      break;
  630.       case GL_PACK_SKIP_ROWS:
  631.      *params = INT_TO_BOOL(ctx->Pack.SkipRows);
  632.      break;
  633.       case GL_PACK_SWAP_BYTES:
  634.      *params = ctx->Pack.SwapBytes;
  635.      break;
  636.       case GL_PACK_SKIP_IMAGES_EXT:
  637.          *params = ctx->Pack.SkipImages;
  638.          break;
  639.       case GL_PACK_IMAGE_HEIGHT_EXT:
  640.          *params = ctx->Pack.ImageHeight;
  641.          break;
  642.       case GL_PERSPECTIVE_CORRECTION_HINT:
  643.      *params = ENUM_TO_BOOL(ctx->Hint.PerspectiveCorrection);
  644.      break;
  645.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  646.      *params = INT_TO_BOOL(ctx->Pixel.MapAtoAsize);
  647.      break;
  648.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  649.      *params = INT_TO_BOOL(ctx->Pixel.MapBtoBsize);
  650.      break;
  651.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  652.      *params = INT_TO_BOOL(ctx->Pixel.MapGtoGsize);
  653.      break;
  654.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  655.      *params = INT_TO_BOOL(ctx->Pixel.MapItoAsize);
  656.      break;
  657.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  658.      *params = INT_TO_BOOL(ctx->Pixel.MapItoBsize);
  659.      break;
  660.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  661.      *params = INT_TO_BOOL(ctx->Pixel.MapItoGsize);
  662.      break;
  663.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  664.      *params = INT_TO_BOOL(ctx->Pixel.MapItoIsize);
  665.      break;
  666.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  667.      *params = INT_TO_BOOL(ctx->Pixel.MapItoRsize);
  668.      break;
  669.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  670.      *params = INT_TO_BOOL(ctx->Pixel.MapRtoRsize);
  671.      break;
  672.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  673.      *params = INT_TO_BOOL(ctx->Pixel.MapStoSsize);
  674.      break;
  675.       case GL_POINT_SIZE:
  676.      *params = FLOAT_TO_BOOL(ctx->Point.Size );
  677.      break;
  678.       case GL_POINT_SIZE_GRANULARITY:
  679.      *params = FLOAT_TO_BOOL(POINT_SIZE_GRANULARITY );
  680.      break;
  681.       case GL_POINT_SIZE_RANGE:
  682.      params[0] = FLOAT_TO_BOOL(MIN_POINT_SIZE );
  683.      params[1] = FLOAT_TO_BOOL(MAX_POINT_SIZE );
  684.      break;
  685.       case GL_POINT_SMOOTH:
  686.      *params = ctx->Point.SmoothFlag;
  687.      break;
  688.       case GL_POINT_SMOOTH_HINT:
  689.      *params = ENUM_TO_BOOL(ctx->Hint.PointSmooth);
  690.      break;
  691.       case GL_POINT_SIZE_MIN_EXT:
  692.      *params = FLOAT_TO_BOOL(ctx->Point.MinSize);
  693.      break;
  694.       case GL_POINT_SIZE_MAX_EXT:
  695.      *params = FLOAT_TO_BOOL(ctx->Point.MaxSize);
  696.      break;
  697.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  698.      *params = FLOAT_TO_BOOL(ctx->Point.Threshold);
  699.      break;
  700.       case GL_DISTANCE_ATTENUATION_EXT:
  701.      params[0] = FLOAT_TO_BOOL(ctx->Point.Params[0]);
  702.      params[1] = FLOAT_TO_BOOL(ctx->Point.Params[1]);
  703.      params[2] = FLOAT_TO_BOOL(ctx->Point.Params[2]);
  704.      break;
  705.       case GL_POLYGON_MODE:
  706.      params[0] = ENUM_TO_BOOL(ctx->Polygon.FrontMode);
  707.      params[1] = ENUM_TO_BOOL(ctx->Polygon.BackMode);
  708.      break;
  709. #ifdef GL_EXT_polygon_offset
  710.       case GL_POLYGON_OFFSET_BIAS_EXT:
  711.          *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetUnits );
  712.          break;
  713. #endif
  714.       case GL_POLYGON_OFFSET_FACTOR:
  715.          *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetFactor );
  716.          break;
  717.       case GL_POLYGON_OFFSET_UNITS:
  718.          *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetUnits );
  719.          break;
  720.       case GL_POLYGON_SMOOTH:
  721.      *params = ctx->Polygon.SmoothFlag;
  722.      break;
  723.       case GL_POLYGON_SMOOTH_HINT:
  724.      *params = ENUM_TO_BOOL(ctx->Hint.PolygonSmooth);
  725.      break;
  726.       case GL_POLYGON_STIPPLE:
  727.      *params = ctx->Polygon.StippleFlag;
  728.      break;
  729.       case GL_PROJECTION_MATRIX:
  730.      for (i=0;i<16;i++) {
  731.         params[i] = FLOAT_TO_BOOL(ctx->ProjectionMatrix[i]);
  732.      }
  733.      break;
  734.       case GL_PROJECTION_STACK_DEPTH:
  735.      *params = INT_TO_BOOL(ctx->ProjectionStackDepth + 1);
  736.      break;
  737.       case GL_READ_BUFFER:
  738.      *params = ENUM_TO_BOOL(ctx->Pixel.ReadBuffer);
  739.      break;
  740.       case GL_RED_BIAS:
  741.          *params = FLOAT_TO_BOOL(ctx->Pixel.RedBias);
  742.      break;
  743.       case GL_RED_BITS:
  744.          *params = INT_TO_BOOL( ctx->Visual->RedBits );
  745.      break;
  746.       case GL_RED_SCALE:
  747.          *params = FLOAT_TO_BOOL(ctx->Pixel.RedScale);
  748.      break;
  749.       case GL_RENDER_MODE:
  750.      *params = ENUM_TO_BOOL(ctx->RenderMode);
  751.      break;
  752.       case GL_RGBA_MODE:
  753.          *params = ctx->Visual->RGBAflag;
  754.      break;
  755.       case GL_SCISSOR_BOX:
  756.      params[0] = INT_TO_BOOL(ctx->Scissor.X);
  757.      params[1] = INT_TO_BOOL(ctx->Scissor.Y);
  758.      params[2] = INT_TO_BOOL(ctx->Scissor.Width);
  759.      params[3] = INT_TO_BOOL(ctx->Scissor.Height);
  760.      break;
  761.       case GL_SCISSOR_TEST:
  762.      *params = ctx->Scissor.Enabled;
  763.      break;
  764.       case GL_SELECTION_BUFFER_SIZE:
  765.          *params = INT_TO_BOOL(ctx->Select.BufferSize);
  766.          break;
  767.       case GL_SHADE_MODEL:
  768.      *params = ENUM_TO_BOOL(ctx->Light.ShadeModel);
  769.      break;
  770.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  771.          *params = ctx->Texture.SharedPalette;
  772.          break;
  773.       case GL_STENCIL_BITS:
  774.      *params = INT_TO_BOOL(ctx->Visual->StencilBits);
  775.      break;
  776.       case GL_STENCIL_CLEAR_VALUE:
  777.      *params = INT_TO_BOOL(ctx->Stencil.Clear);
  778.      break;
  779.       case GL_STENCIL_FAIL:
  780.      *params = ENUM_TO_BOOL(ctx->Stencil.FailFunc);
  781.      break;
  782.       case GL_STENCIL_FUNC:
  783.      *params = ENUM_TO_BOOL(ctx->Stencil.Function);
  784.      break;
  785.       case GL_STENCIL_PASS_DEPTH_FAIL:
  786.      *params = ENUM_TO_BOOL(ctx->Stencil.ZFailFunc);
  787.      break;
  788.       case GL_STENCIL_PASS_DEPTH_PASS:
  789.      *params = ENUM_TO_BOOL(ctx->Stencil.ZPassFunc);
  790.      break;
  791.       case GL_STENCIL_REF:
  792.      *params = INT_TO_BOOL(ctx->Stencil.Ref);
  793.      break;
  794.       case GL_STENCIL_TEST:
  795.      *params = ctx->Stencil.Enabled;
  796.      break;
  797.       case GL_STENCIL_VALUE_MASK:
  798.      *params = INT_TO_BOOL(ctx->Stencil.ValueMask);
  799.      break;
  800.       case GL_STENCIL_WRITEMASK:
  801.      *params = INT_TO_BOOL(ctx->Stencil.WriteMask);
  802.      break;
  803.       case GL_STEREO:
  804.      *params = GL_FALSE;    /* TODO */
  805.      break;
  806.       case GL_SUBPIXEL_BITS:
  807.      *params = INT_TO_BOOL(0);  /* TODO */
  808.      break;
  809.       case GL_TEXTURE_1D:
  810.          {
  811.             GLuint bit = TEXTURE0_1D << (texSet * 4);
  812.             *params = (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  813.          }
  814.      break;
  815.       case GL_TEXTURE_2D:
  816.          {
  817.             GLuint bit = TEXTURE0_2D << (texSet * 4);
  818.             *params = (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  819.          }
  820.      break;
  821.       case GL_TEXTURE_3D:
  822.          {
  823.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  824.             *params = (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  825.          }
  826.      break;
  827.       case GL_TEXTURE_BINDING_1D:
  828.          *params = INT_TO_BOOL(textureSet->Current1D->Name);
  829.           break;
  830.       case GL_TEXTURE_BINDING_2D:
  831.          *params = INT_TO_BOOL(textureSet->Current2D->Name);
  832.           break;
  833.       case GL_TEXTURE_BINDING_3D:
  834.          *params = INT_TO_BOOL(textureSet->Current2D->Name);
  835.           break;
  836.       case GL_TEXTURE_ENV_COLOR:
  837.          {
  838.             params[0] = FLOAT_TO_BOOL(textureSet->EnvColor[0]);
  839.             params[1] = FLOAT_TO_BOOL(textureSet->EnvColor[1]);
  840.             params[2] = FLOAT_TO_BOOL(textureSet->EnvColor[2]);
  841.             params[3] = FLOAT_TO_BOOL(textureSet->EnvColor[3]);
  842.          }
  843.      break;
  844.       case GL_TEXTURE_ENV_MODE:
  845.      *params = ENUM_TO_BOOL(textureSet->EnvMode);
  846.      break;
  847.       case GL_TEXTURE_GEN_S:
  848.      *params = (textureSet->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
  849.      break;
  850.       case GL_TEXTURE_GEN_T:
  851.      *params = (textureSet->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
  852.      break;
  853.       case GL_TEXTURE_GEN_R:
  854.      *params = (textureSet->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
  855.      break;
  856.       case GL_TEXTURE_GEN_Q:
  857.      *params = (textureSet->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
  858.      break;
  859.       case GL_TEXTURE_MATRIX:
  860.      for (i=0;i<16;i++) {
  861.         params[i] = FLOAT_TO_BOOL(ctx->TextureMatrix[texTransformSet][i]);
  862.      }
  863.      break;
  864.       case GL_TEXTURE_STACK_DEPTH:
  865.      *params = INT_TO_BOOL(ctx->TextureStackDepth[texTransformSet] + 1);
  866.      break;
  867.       case GL_UNPACK_ALIGNMENT:
  868.      *params = INT_TO_BOOL(ctx->Unpack.Alignment);
  869.      break;
  870.       case GL_UNPACK_LSB_FIRST:
  871.      *params = ctx->Unpack.LsbFirst;
  872.      break;
  873.       case GL_UNPACK_ROW_LENGTH:
  874.      *params = INT_TO_BOOL(ctx->Unpack.RowLength);
  875.      break;
  876.       case GL_UNPACK_SKIP_PIXELS:
  877.      *params = INT_TO_BOOL(ctx->Unpack.SkipPixels);
  878.      break;
  879.       case GL_UNPACK_SKIP_ROWS:
  880.      *params = INT_TO_BOOL(ctx->Unpack.SkipRows);
  881.      break;
  882.       case GL_UNPACK_SWAP_BYTES:
  883.      *params = ctx->Unpack.SwapBytes;
  884.      break;
  885.       case GL_UNPACK_SKIP_IMAGES_EXT:
  886.          *params = ctx->Unpack.SkipImages;
  887.          break;
  888.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  889.          *params = ctx->Unpack.ImageHeight;
  890.          break;
  891.       case GL_VIEWPORT:
  892.      params[0] = INT_TO_BOOL(ctx->Viewport.X);
  893.      params[1] = INT_TO_BOOL(ctx->Viewport.Y);
  894.      params[2] = INT_TO_BOOL(ctx->Viewport.Width);
  895.      params[3] = INT_TO_BOOL(ctx->Viewport.Height);
  896.      break;
  897.       case GL_ZOOM_X:
  898.      *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomX);
  899.      break;
  900.       case GL_ZOOM_Y:
  901.      *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomY);
  902.      break;
  903.       case GL_VERTEX_ARRAY_SIZE:
  904.          *params = INT_TO_BOOL(ctx->Array.VertexSize);
  905.          break;
  906.       case GL_VERTEX_ARRAY_TYPE:
  907.          *params = ENUM_TO_BOOL(ctx->Array.VertexType);
  908.          break;
  909.       case GL_VERTEX_ARRAY_STRIDE:
  910.          *params = INT_TO_BOOL(ctx->Array.VertexStride);
  911.          break;
  912.       case GL_VERTEX_ARRAY_COUNT_EXT:
  913.          *params = INT_TO_BOOL(0);
  914.          break;
  915.       case GL_NORMAL_ARRAY_TYPE:
  916.          *params = ENUM_TO_BOOL(ctx->Array.NormalType);
  917.          break;
  918.       case GL_NORMAL_ARRAY_STRIDE:
  919.          *params = INT_TO_BOOL(ctx->Array.NormalStride);
  920.          break;
  921.       case GL_NORMAL_ARRAY_COUNT_EXT:
  922.          *params = INT_TO_BOOL(0);
  923.          break;
  924.       case GL_COLOR_ARRAY_SIZE:
  925.          *params = INT_TO_BOOL(ctx->Array.ColorSize);
  926.          break;
  927.       case GL_COLOR_ARRAY_TYPE:
  928.          *params = ENUM_TO_BOOL(ctx->Array.ColorType);
  929.          break;
  930.       case GL_COLOR_ARRAY_STRIDE:
  931.          *params = INT_TO_BOOL(ctx->Array.ColorStride);
  932.          break;
  933.       case GL_COLOR_ARRAY_COUNT_EXT:
  934.          *params = INT_TO_BOOL(0);
  935.          break;
  936.       case GL_INDEX_ARRAY_TYPE:
  937.          *params = ENUM_TO_BOOL(ctx->Array.IndexType);
  938.          break;
  939.       case GL_INDEX_ARRAY_STRIDE:
  940.          *params = INT_TO_BOOL(ctx->Array.IndexStride);
  941.          break;
  942.       case GL_INDEX_ARRAY_COUNT_EXT:
  943.          *params = INT_TO_BOOL(0);
  944.          break;
  945.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  946.          *params = INT_TO_BOOL(ctx->Array.TexCoordSize[texSet]);
  947.          break;
  948.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  949.          *params = ENUM_TO_BOOL(ctx->Array.TexCoordType[texSet]);
  950.          break;
  951.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  952.          *params = INT_TO_BOOL(ctx->Array.TexCoordStride[texSet]);
  953.          break;
  954.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  955.          *params = INT_TO_BOOL(0);
  956.          break;
  957.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  958.          *params = INT_TO_BOOL(ctx->Array.EdgeFlagStride);
  959.          break;
  960.       case GL_EDGE_FLAG_ARRAY_EXT:
  961.          *params = INT_TO_BOOL(0);
  962.          break;
  963.  
  964.       /* GL_SGIS_multitexture */
  965.       case GL_SELECTED_TEXTURE_SGIS:
  966.          *params = INT_TO_BOOL(ctx->Texture.CurrentSet);
  967.          break;
  968.       case GL_SELECTED_TEXTURE_COORD_SET_SGIS:
  969.          *params = INT_TO_BOOL(ctx->TexCoordSet);
  970.          break;
  971.       case GL_MAX_TEXTURES_SGIS:
  972.          *params = INT_TO_BOOL(max_textures(ctx));
  973.          break;
  974.  
  975.       /* GL_EXT_multitexture */
  976.       case GL_SELECTED_TEXTURE_EXT:
  977.          *params = INT_TO_BOOL(ctx->Texture.CurrentSet);
  978.          break;
  979.       case GL_SELECTED_TEXTURE_COORD_SET_EXT:
  980.          *params = INT_TO_BOOL(ctx->TexCoordSet);
  981.          break;
  982.       case GL_SELECTED_TEXTURE_TRANSFORM_EXT:
  983.          *params = INT_TO_BOOL(ctx->Texture.CurrentTransformSet);
  984.          break;
  985.       case GL_MAX_TEXTURES_EXT:
  986.          *params = INT_TO_BOOL(max_textures(ctx));
  987.          break;
  988.       case GL_MAX_TEXTURE_COORD_SETS_EXT:
  989.          *params = INT_TO_BOOL(MAX_TEX_COORD_SETS);
  990.          break;
  991.  
  992.       default:
  993.          gl_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
  994.    }
  995. }
  996.  
  997.  
  998.  
  999.  
  1000. void gl_GetDoublev( GLcontext *ctx, GLenum pname, GLdouble *params )
  1001. {
  1002.    GLuint i;
  1003.    GLuint texSet = ctx->Texture.CurrentSet;
  1004.    GLuint texTransformSet = ctx->Texture.CurrentTransformSet;
  1005.    const struct gl_texture_set *textureSet = &ctx->Texture.Set[texSet];
  1006.  
  1007.    if (INSIDE_BEGIN_END(ctx)) {
  1008.       gl_error( ctx, GL_INVALID_OPERATION, "glGetDoublev" );
  1009.       return;
  1010.    }
  1011.  
  1012.    switch (pname) {
  1013.       case GL_ACCUM_RED_BITS:
  1014.       case GL_ACCUM_GREEN_BITS:
  1015.       case GL_ACCUM_BLUE_BITS:
  1016.       case GL_ACCUM_ALPHA_BITS:
  1017.          *params = (GLdouble) ctx->Visual->AccumBits;
  1018.          break;
  1019.       case GL_ACCUM_CLEAR_VALUE:
  1020.          params[0] = (GLdouble) ctx->Accum.ClearColor[0];
  1021.          params[1] = (GLdouble) ctx->Accum.ClearColor[1];
  1022.          params[2] = (GLdouble) ctx->Accum.ClearColor[2];
  1023.          params[3] = (GLdouble) ctx->Accum.ClearColor[3];
  1024.          break;
  1025.       case GL_ALPHA_BIAS:
  1026.          *params = (GLdouble) ctx->Pixel.AlphaBias;
  1027.          break;
  1028.       case GL_ALPHA_BITS:
  1029.          *params = (GLdouble) ctx->Visual->AlphaBits;
  1030.          break;
  1031.       case GL_ALPHA_SCALE:
  1032.          *params = (GLdouble) ctx->Pixel.AlphaScale;
  1033.          break;
  1034.       case GL_ALPHA_TEST:
  1035.          *params = (GLdouble) ctx->Color.AlphaEnabled;
  1036.          break;
  1037.       case GL_ALPHA_TEST_FUNC:
  1038.          *params = ENUM_TO_DOUBLE(ctx->Color.AlphaFunc);
  1039.          break;
  1040.       case GL_ALPHA_TEST_REF:
  1041.          *params = (GLdouble) ctx->Color.AlphaRef / 255.0;
  1042.          break;
  1043.       case GL_ATTRIB_STACK_DEPTH:
  1044.          *params = (GLdouble ) (ctx->AttribStackDepth);
  1045.          break;
  1046.       case GL_AUTO_NORMAL:
  1047.          *params = (GLdouble) ctx->Eval.AutoNormal;
  1048.          break;
  1049.       case GL_AUX_BUFFERS:
  1050.          *params = (GLdouble) NUM_AUX_BUFFERS;
  1051.          break;
  1052.       case GL_BLEND:
  1053.          *params = (GLdouble) ctx->Color.BlendEnabled;
  1054.          break;
  1055.       case GL_BLEND_DST:
  1056.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendDst);
  1057.          break;
  1058.       case GL_BLEND_SRC:
  1059.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrc);
  1060.          break;
  1061.       case GL_BLEND_EQUATION_EXT:
  1062.      *params = ENUM_TO_DOUBLE(ctx->Color.BlendEquation);
  1063.      break;
  1064.       case GL_BLEND_COLOR_EXT:
  1065.      params[0] = (GLdouble) ctx->Color.BlendColor[0];
  1066.      params[1] = (GLdouble) ctx->Color.BlendColor[1];
  1067.      params[2] = (GLdouble) ctx->Color.BlendColor[2];
  1068.      params[3] = (GLdouble) ctx->Color.BlendColor[3];
  1069.      break;
  1070.       case GL_BLUE_BIAS:
  1071.          *params = (GLdouble) ctx->Pixel.BlueBias;
  1072.          break;
  1073.       case GL_BLUE_BITS:
  1074.          *params = (GLdouble) ctx->Visual->BlueBits;
  1075.          break;
  1076.       case GL_BLUE_SCALE:
  1077.          *params = (GLdouble) ctx->Pixel.BlueScale;
  1078.          break;
  1079.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  1080.          *params = (GLdouble) (ctx->ClientAttribStackDepth);
  1081.          break;
  1082.       case GL_CLIP_PLANE0:
  1083.       case GL_CLIP_PLANE1:
  1084.       case GL_CLIP_PLANE2:
  1085.       case GL_CLIP_PLANE3:
  1086.       case GL_CLIP_PLANE4:
  1087.       case GL_CLIP_PLANE5:
  1088.          *params = (GLdouble) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  1089.          break;
  1090.       case GL_COLOR_CLEAR_VALUE:
  1091.          params[0] = (GLdouble) ctx->Color.ClearColor[0];
  1092.          params[1] = (GLdouble) ctx->Color.ClearColor[1];
  1093.          params[2] = (GLdouble) ctx->Color.ClearColor[2];
  1094.          params[3] = (GLdouble) ctx->Color.ClearColor[3];
  1095.          break;
  1096.       case GL_COLOR_MATERIAL:
  1097.          *params = (GLdouble) ctx->Light.ColorMaterialEnabled;
  1098.          break;
  1099.       case GL_COLOR_MATERIAL_FACE:
  1100.          *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialFace);
  1101.          break;
  1102.       case GL_COLOR_MATERIAL_PARAMETER:
  1103.          *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialMode);
  1104.          break;
  1105.       case GL_COLOR_WRITEMASK:
  1106.          params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0 : 0.0;
  1107.          params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0 : 0.0;
  1108.          params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0 : 0.0;
  1109.          params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0 : 0.0;
  1110.          break;
  1111.       case GL_CULL_FACE:
  1112.          *params = (GLdouble) ctx->Polygon.CullFlag;
  1113.          break;
  1114.       case GL_CULL_FACE_MODE:
  1115.          *params = ENUM_TO_DOUBLE(ctx->Polygon.CullFaceMode);
  1116.          break;
  1117.       case GL_CURRENT_COLOR:
  1118.          params[0] = (GLfloat) ctx->Current.ByteColor[0] / 255.0F;
  1119.          params[1] = (GLfloat) ctx->Current.ByteColor[1] / 255.0F;
  1120.          params[2] = (GLfloat) ctx->Current.ByteColor[2] / 255.0F;
  1121.          params[3] = (GLfloat) ctx->Current.ByteColor[3] / 255.0F;
  1122.          break;
  1123.       case GL_CURRENT_INDEX:
  1124.          *params = (GLdouble) ctx->Current.Index;
  1125.          break;
  1126.       case GL_CURRENT_NORMAL:
  1127.          params[0] = (GLdouble) ctx->Current.Normal[0];
  1128.          params[1] = (GLdouble) ctx->Current.Normal[1];
  1129.          params[2] = (GLdouble) ctx->Current.Normal[2];
  1130.          break;
  1131.       case GL_CURRENT_RASTER_COLOR:
  1132.      params[0] = (GLdouble) ctx->Current.RasterColor[0];
  1133.      params[1] = (GLdouble) ctx->Current.RasterColor[1];
  1134.      params[2] = (GLdouble) ctx->Current.RasterColor[2];
  1135.      params[3] = (GLdouble) ctx->Current.RasterColor[3];
  1136.      break;
  1137.       case GL_CURRENT_RASTER_DISTANCE:
  1138.      params[0] = (GLdouble) ctx->Current.RasterDistance;
  1139.      break;
  1140.       case GL_CURRENT_RASTER_INDEX:
  1141.      *params = (GLdouble) ctx->Current.RasterIndex;
  1142.      break;
  1143.       case GL_CURRENT_RASTER_POSITION:
  1144.      params[0] = (GLdouble) ctx->Current.RasterPos[0];
  1145.      params[1] = (GLdouble) ctx->Current.RasterPos[1];
  1146.      params[2] = (GLdouble) ctx->Current.RasterPos[2];
  1147.      params[3] = (GLdouble) ctx->Current.RasterPos[3];
  1148.      break;
  1149.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  1150.      params[0] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformSet][0];
  1151.      params[1] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformSet][1];
  1152.      params[2] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformSet][2];
  1153.      params[3] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformSet][3];
  1154.      break;
  1155.       case GL_CURRENT_RASTER_POSITION_VALID:
  1156.      *params = (GLdouble) ctx->Current.RasterPosValid;
  1157.      break;
  1158.       case GL_CURRENT_TEXTURE_COORDS:
  1159.      params[0] = (GLdouble) ctx->Current.MultiTexCoord[texTransformSet][0];
  1160.      params[1] = (GLdouble) ctx->Current.MultiTexCoord[texTransformSet][1];
  1161.      params[2] = (GLdouble) ctx->Current.MultiTexCoord[texTransformSet][2];
  1162.      params[3] = (GLdouble) ctx->Current.MultiTexCoord[texTransformSet][3];
  1163.      break;
  1164.       case GL_DEPTH_BIAS:
  1165.      *params = (GLdouble) ctx->Pixel.DepthBias;
  1166.      break;
  1167.       case GL_DEPTH_BITS:
  1168.      *params = (GLdouble) ctx->Visual->DepthBits;
  1169.      break;
  1170.       case GL_DEPTH_CLEAR_VALUE:
  1171.      *params = (GLdouble) ctx->Depth.Clear;
  1172.      break;
  1173.       case GL_DEPTH_FUNC:
  1174.      *params = ENUM_TO_DOUBLE(ctx->Depth.Func);
  1175.      break;
  1176.       case GL_DEPTH_RANGE:
  1177.          params[0] = (GLdouble) ctx->Viewport.Near;
  1178.          params[1] = (GLdouble) ctx->Viewport.Far;
  1179.      break;
  1180.       case GL_DEPTH_SCALE:
  1181.      *params = (GLdouble) ctx->Pixel.DepthScale;
  1182.      break;
  1183.       case GL_DEPTH_TEST:
  1184.      *params = (GLdouble) ctx->Depth.Test;
  1185.      break;
  1186.       case GL_DEPTH_WRITEMASK:
  1187.      *params = (GLdouble) ctx->Depth.Mask;
  1188.      break;
  1189.       case GL_DITHER:
  1190.      *params = (GLdouble) ctx->Color.DitherFlag;
  1191.      break;
  1192.       case GL_DOUBLEBUFFER:
  1193.      *params = (GLdouble) ctx->Visual->DBflag;
  1194.      break;
  1195.       case GL_DRAW_BUFFER:
  1196.      *params = ENUM_TO_DOUBLE(ctx->Color.DrawBuffer);
  1197.      break;
  1198.       case GL_EDGE_FLAG:
  1199.      *params = (GLdouble) ctx->Current.EdgeFlag;
  1200.      break;
  1201.       case GL_FEEDBACK_BUFFER_SIZE:
  1202.          /* TODO: is this right?  Or, return number of entries in buffer? */
  1203.          *params = (GLdouble) ctx->Feedback.BufferSize;
  1204.          break;
  1205.       case GL_FEEDBACK_BUFFER_TYPE:
  1206.          *params = ENUM_TO_DOUBLE(ctx->Feedback.Type);
  1207.          break;
  1208.       case GL_FOG:
  1209.      *params = (GLdouble) ctx->Fog.Enabled;
  1210.      break;
  1211.       case GL_FOG_COLOR:
  1212.      params[0] = (GLdouble) ctx->Fog.Color[0];
  1213.      params[1] = (GLdouble) ctx->Fog.Color[1];
  1214.      params[2] = (GLdouble) ctx->Fog.Color[2];
  1215.      params[3] = (GLdouble) ctx->Fog.Color[3];
  1216.      break;
  1217.       case GL_FOG_DENSITY:
  1218.      *params = (GLdouble) ctx->Fog.Density;
  1219.      break;
  1220.       case GL_FOG_END:
  1221.      *params = (GLdouble) ctx->Fog.End;
  1222.      break;
  1223.       case GL_FOG_HINT:
  1224.      *params = ENUM_TO_DOUBLE(ctx->Hint.Fog);
  1225.      break;
  1226.       case GL_FOG_INDEX:
  1227.      *params = (GLdouble) ctx->Fog.Index;
  1228.      break;
  1229.       case GL_FOG_MODE:
  1230.      *params = ENUM_TO_DOUBLE(ctx->Fog.Mode);
  1231.      break;
  1232.       case GL_FOG_START:
  1233.      *params = (GLdouble) ctx->Fog.Start;
  1234.      break;
  1235.       case GL_FRONT_FACE:
  1236.      *params = ENUM_TO_DOUBLE(ctx->Polygon.FrontFace);
  1237.      break;
  1238.       case GL_GREEN_BIAS:
  1239.          *params = (GLdouble) ctx->Pixel.GreenBias;
  1240.          break;
  1241.       case GL_GREEN_BITS:
  1242.          *params = (GLdouble) ctx->Visual->GreenBits;
  1243.          break;
  1244.       case GL_GREEN_SCALE:
  1245.          *params = (GLdouble) ctx->Pixel.GreenScale;
  1246.          break;
  1247.       case GL_INDEX_BITS:
  1248.          *params = (GLdouble) ctx->Visual->IndexBits;
  1249.      break;
  1250.       case GL_INDEX_CLEAR_VALUE:
  1251.          *params = (GLdouble) ctx->Color.ClearIndex;
  1252.      break;
  1253.       case GL_INDEX_MODE:
  1254.      *params = ctx->Visual->RGBAflag ? 0.0 : 1.0;
  1255.      break;
  1256.       case GL_INDEX_OFFSET:
  1257.      *params = (GLdouble) ctx->Pixel.IndexOffset;
  1258.      break;
  1259.       case GL_INDEX_SHIFT:
  1260.      *params = (GLdouble) ctx->Pixel.IndexShift;
  1261.      break;
  1262.       case GL_INDEX_WRITEMASK:
  1263.      *params = (GLdouble) ctx->Color.IndexMask;
  1264.      break;
  1265.       case GL_LIGHT0:
  1266.       case GL_LIGHT1:
  1267.       case GL_LIGHT2:
  1268.       case GL_LIGHT3:
  1269.       case GL_LIGHT4:
  1270.       case GL_LIGHT5:
  1271.       case GL_LIGHT6:
  1272.       case GL_LIGHT7:
  1273.      *params = (GLdouble) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  1274.      break;
  1275.       case GL_LIGHTING:
  1276.      *params = (GLdouble) ctx->Light.Enabled;
  1277.      break;
  1278.       case GL_LIGHT_MODEL_AMBIENT:
  1279.      params[0] = (GLdouble) ctx->Light.Model.Ambient[0];
  1280.      params[1] = (GLdouble) ctx->Light.Model.Ambient[1];
  1281.      params[2] = (GLdouble) ctx->Light.Model.Ambient[2];
  1282.      params[3] = (GLdouble) ctx->Light.Model.Ambient[3];
  1283.      break;
  1284.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  1285.          params[0] = (GLdouble) ctx->Light.Model.ColorControl;
  1286.          break;
  1287.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1288.      *params = (GLdouble) ctx->Light.Model.LocalViewer;
  1289.      break;
  1290.       case GL_LIGHT_MODEL_TWO_SIDE:
  1291.      *params = (GLdouble) ctx->Light.Model.TwoSide;
  1292.      break;
  1293.       case GL_LINE_SMOOTH:
  1294.      *params = (GLdouble) ctx->Line.SmoothFlag;
  1295.      break;
  1296.       case GL_LINE_SMOOTH_HINT:
  1297.      *params = ENUM_TO_DOUBLE(ctx->Hint.LineSmooth);
  1298.      break;
  1299.       case GL_LINE_STIPPLE:
  1300.      *params = (GLdouble) ctx->Line.StippleFlag;
  1301.      break;
  1302.       case GL_LINE_STIPPLE_PATTERN:
  1303.          *params = (GLdouble) ctx->Line.StipplePattern;
  1304.          break;
  1305.       case GL_LINE_STIPPLE_REPEAT:
  1306.          *params = (GLdouble) ctx->Line.StippleFactor;
  1307.          break;
  1308.       case GL_LINE_WIDTH:
  1309.      *params = (GLdouble) ctx->Line.Width;
  1310.      break;
  1311.       case GL_LINE_WIDTH_GRANULARITY:
  1312.      *params = (GLdouble) LINE_WIDTH_GRANULARITY;
  1313.      break;
  1314.       case GL_LINE_WIDTH_RANGE:
  1315.      params[0] = (GLdouble) MIN_LINE_WIDTH;
  1316.      params[1] = (GLdouble) MAX_LINE_WIDTH;
  1317.      break;
  1318.       case GL_LIST_BASE:
  1319.      *params = (GLdouble) ctx->List.ListBase;
  1320.      break;
  1321.       case GL_LIST_INDEX:
  1322.      *params = (GLdouble) ctx->CurrentListNum;
  1323.      break;
  1324.       case GL_LIST_MODE:
  1325.      *params = ctx->ExecuteFlag ? ENUM_TO_DOUBLE(GL_COMPILE_AND_EXECUTE)
  1326.                      : ENUM_TO_DOUBLE(GL_COMPILE);
  1327.      break;
  1328.       case GL_INDEX_LOGIC_OP:
  1329.      *params = (GLdouble) ctx->Color.IndexLogicOpEnabled;
  1330.      break;
  1331.       case GL_COLOR_LOGIC_OP:
  1332.      *params = (GLdouble) ctx->Color.ColorLogicOpEnabled;
  1333.      break;
  1334.       case GL_LOGIC_OP_MODE:
  1335.          *params = ENUM_TO_DOUBLE(ctx->Color.LogicOp);
  1336.      break;
  1337.       case GL_MAP1_COLOR_4:
  1338.      *params = (GLdouble) ctx->Eval.Map1Color4;
  1339.      break;
  1340.       case GL_MAP1_GRID_DOMAIN:
  1341.      params[0] = (GLdouble) ctx->Eval.MapGrid1u1;
  1342.      params[1] = (GLdouble) ctx->Eval.MapGrid1u2;
  1343.      break;
  1344.       case GL_MAP1_GRID_SEGMENTS:
  1345.      *params = (GLdouble) ctx->Eval.MapGrid1un;
  1346.      break;
  1347.       case GL_MAP1_INDEX:
  1348.      *params = (GLdouble) ctx->Eval.Map1Index;
  1349.      break;
  1350.       case GL_MAP1_NORMAL:
  1351.      *params = (GLdouble) ctx->Eval.Map1Normal;
  1352.      break;
  1353.       case GL_MAP1_TEXTURE_COORD_1:
  1354.      *params = (GLdouble) ctx->Eval.Map1TextureCoord1;
  1355.      break;
  1356.       case GL_MAP1_TEXTURE_COORD_2:
  1357.      *params = (GLdouble) ctx->Eval.Map1TextureCoord2;
  1358.      break;
  1359.       case GL_MAP1_TEXTURE_COORD_3:
  1360.      *params = (GLdouble) ctx->Eval.Map1TextureCoord3;
  1361.      break;
  1362.       case GL_MAP1_TEXTURE_COORD_4:
  1363.      *params = (GLdouble) ctx->Eval.Map1TextureCoord4;
  1364.      break;
  1365.       case GL_MAP1_VERTEX_3:
  1366.      *params = (GLdouble) ctx->Eval.Map1Vertex3;
  1367.      break;
  1368.       case GL_MAP1_VERTEX_4:
  1369.      *params = (GLdouble) ctx->Eval.Map1Vertex4;
  1370.      break;
  1371.       case GL_MAP2_COLOR_4:
  1372.      *params = (GLdouble) ctx->Eval.Map2Color4;
  1373.      break;
  1374.       case GL_MAP2_GRID_DOMAIN:
  1375.      params[0] = (GLdouble) ctx->Eval.MapGrid2u1;
  1376.      params[1] = (GLdouble) ctx->Eval.MapGrid2u2;
  1377.      params[2] = (GLdouble) ctx->Eval.MapGrid2v1;
  1378.      params[3] = (GLdouble) ctx->Eval.MapGrid2v2;
  1379.      break;
  1380.       case GL_MAP2_GRID_SEGMENTS:
  1381.      params[0] = (GLdouble) ctx->Eval.MapGrid2un;
  1382.      params[1] = (GLdouble) ctx->Eval.MapGrid2vn;
  1383.      break;
  1384.       case GL_MAP2_INDEX:
  1385.      *params = (GLdouble) ctx->Eval.Map2Index;
  1386.      break;
  1387.       case GL_MAP2_NORMAL:
  1388.      *params = (GLdouble) ctx->Eval.Map2Normal;
  1389.      break;
  1390.       case GL_MAP2_TEXTURE_COORD_1:
  1391.      *params = (GLdouble) ctx->Eval.Map2TextureCoord1;
  1392.      break;
  1393.       case GL_MAP2_TEXTURE_COORD_2:
  1394.      *params = (GLdouble) ctx->Eval.Map2TextureCoord2;
  1395.      break;
  1396.       case GL_MAP2_TEXTURE_COORD_3:
  1397.      *params = (GLdouble) ctx->Eval.Map2TextureCoord3;
  1398.      break;
  1399.       case GL_MAP2_TEXTURE_COORD_4:
  1400.      *params = (GLdouble) ctx->Eval.Map2TextureCoord4;
  1401.      break;
  1402.       case GL_MAP2_VERTEX_3:
  1403.      *params = (GLdouble) ctx->Eval.Map2Vertex3;
  1404.      break;
  1405.       case GL_MAP2_VERTEX_4:
  1406.      *params = (GLdouble) ctx->Eval.Map2Vertex4;
  1407.      break;
  1408.       case GL_MAP_COLOR:
  1409.      *params = (GLdouble) ctx->Pixel.MapColorFlag;
  1410.      break;
  1411.       case GL_MAP_STENCIL:
  1412.      *params = (GLdouble) ctx->Pixel.MapStencilFlag;
  1413.      break;
  1414.       case GL_MATRIX_MODE:
  1415.      *params = ENUM_TO_DOUBLE(ctx->Transform.MatrixMode);
  1416.      break;
  1417.       case GL_MAX_ATTRIB_STACK_DEPTH:
  1418.      *params = (GLdouble) MAX_ATTRIB_STACK_DEPTH;
  1419.      break;
  1420.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  1421.          *params = (GLdouble) MAX_CLIENT_ATTRIB_STACK_DEPTH;
  1422.          break;
  1423.       case GL_MAX_CLIP_PLANES:
  1424.      *params = (GLdouble) MAX_CLIP_PLANES;
  1425.      break;
  1426.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  1427.          *params = (GLdouble) VB_MAX;
  1428.          break;
  1429.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  1430.          *params = (GLdouble) VB_MAX;
  1431.          break;
  1432.       case GL_MAX_EVAL_ORDER:
  1433.      *params = (GLdouble) MAX_EVAL_ORDER;
  1434.      break;
  1435.       case GL_MAX_LIGHTS:
  1436.      *params = (GLdouble) MAX_LIGHTS;
  1437.      break;
  1438.       case GL_MAX_LIST_NESTING:
  1439.      *params = (GLdouble) MAX_LIST_NESTING;
  1440.      break;
  1441.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  1442.      *params = (GLdouble) MAX_MODELVIEW_STACK_DEPTH;
  1443.      break;
  1444.       case GL_MAX_NAME_STACK_DEPTH:
  1445.      *params = (GLdouble) MAX_NAME_STACK_DEPTH;
  1446.      break;
  1447.       case GL_MAX_PIXEL_MAP_TABLE:
  1448.      *params = (GLdouble) MAX_PIXEL_MAP_TABLE;
  1449.      break;
  1450.       case GL_MAX_PROJECTION_STACK_DEPTH:
  1451.      *params = (GLdouble) MAX_PROJECTION_STACK_DEPTH;
  1452.      break;
  1453.       case GL_MAX_TEXTURE_SIZE:
  1454.       case GL_MAX_3D_TEXTURE_SIZE:
  1455.          *params = (GLdouble) max_texture_size(ctx);
  1456.      break;
  1457.       case GL_MAX_TEXTURE_STACK_DEPTH:
  1458.      *params = (GLdouble) MAX_TEXTURE_STACK_DEPTH;
  1459.      break;
  1460.       case GL_MAX_VIEWPORT_DIMS:
  1461.          params[0] = (GLdouble) MAX_WIDTH;
  1462.          params[1] = (GLdouble) MAX_HEIGHT;
  1463.          break;
  1464.       case GL_MODELVIEW_MATRIX:
  1465.      for (i=0;i<16;i++) {
  1466.         params[i] = (GLdouble) ctx->ModelViewMatrix[i];
  1467.      }
  1468.      break;
  1469.       case GL_MODELVIEW_STACK_DEPTH:
  1470.      *params = (GLdouble) (ctx->ModelViewStackDepth + 1);
  1471.      break;
  1472.       case GL_NAME_STACK_DEPTH:
  1473.      *params = (GLdouble) ctx->Select.NameStackDepth;
  1474.      break;
  1475.       case GL_NORMALIZE:
  1476.      *params = (GLdouble) ctx->Transform.Normalize;
  1477.      break;
  1478.       case GL_PACK_ALIGNMENT:
  1479.      *params = (GLdouble) ctx->Pack.Alignment;
  1480.      break;
  1481.       case GL_PACK_LSB_FIRST:
  1482.      *params = (GLdouble) ctx->Pack.LsbFirst;
  1483.      break;
  1484.       case GL_PACK_ROW_LENGTH:
  1485.      *params = (GLdouble) ctx->Pack.RowLength;
  1486.      break;
  1487.       case GL_PACK_SKIP_PIXELS:
  1488.      *params = (GLdouble) ctx->Pack.SkipPixels;
  1489.      break;
  1490.       case GL_PACK_SKIP_ROWS:
  1491.      *params = (GLdouble) ctx->Pack.SkipRows;
  1492.      break;
  1493.       case GL_PACK_SWAP_BYTES:
  1494.      *params = (GLdouble) ctx->Pack.SwapBytes;
  1495.      break;
  1496.       case GL_PACK_SKIP_IMAGES_EXT:
  1497.          *params = (GLdouble) ctx->Pack.SkipImages;
  1498.          break;
  1499.       case GL_PACK_IMAGE_HEIGHT_EXT:
  1500.          *params = (GLdouble) ctx->Pack.ImageHeight;
  1501.          break;
  1502.       case GL_PERSPECTIVE_CORRECTION_HINT:
  1503.      *params = ENUM_TO_DOUBLE(ctx->Hint.PerspectiveCorrection);
  1504.      break;
  1505.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  1506.      *params = (GLdouble) ctx->Pixel.MapAtoAsize;
  1507.      break;
  1508.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  1509.      *params = (GLdouble) ctx->Pixel.MapBtoBsize;
  1510.      break;
  1511.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  1512.      *params = (GLdouble) ctx->Pixel.MapGtoGsize;
  1513.      break;
  1514.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  1515.      *params = (GLdouble) ctx->Pixel.MapItoAsize;
  1516.      break;
  1517.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  1518.      *params = (GLdouble) ctx->Pixel.MapItoBsize;
  1519.      break;
  1520.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  1521.      *params = (GLdouble) ctx->Pixel.MapItoGsize;
  1522.      break;
  1523.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  1524.      *params = (GLdouble) ctx->Pixel.MapItoIsize;
  1525.      break;
  1526.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  1527.      *params = (GLdouble) ctx->Pixel.MapItoRsize;
  1528.      break;
  1529.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  1530.      *params = (GLdouble) ctx->Pixel.MapRtoRsize;
  1531.      break;
  1532.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  1533.      *params = (GLdouble) ctx->Pixel.MapStoSsize;
  1534.      break;
  1535.       case GL_POINT_SIZE:
  1536.          *params = (GLdouble) ctx->Point.Size;
  1537.          break;
  1538.       case GL_POINT_SIZE_GRANULARITY:
  1539.      *params = (GLdouble) POINT_SIZE_GRANULARITY;
  1540.      break;
  1541.       case GL_POINT_SIZE_RANGE:
  1542.      params[0] = (GLdouble) MIN_POINT_SIZE;
  1543.      params[1] = (GLdouble) MAX_POINT_SIZE;
  1544.      break;
  1545.       case GL_POINT_SMOOTH:
  1546.      *params = (GLdouble) ctx->Point.SmoothFlag;
  1547.      break;
  1548.       case GL_POINT_SMOOTH_HINT:
  1549.      *params = ENUM_TO_DOUBLE(ctx->Hint.PointSmooth);
  1550.      break;
  1551.       case GL_POINT_SIZE_MIN_EXT:
  1552.      *params = (GLdouble) (ctx->Point.MinSize);
  1553.      break;
  1554.       case GL_POINT_SIZE_MAX_EXT:
  1555.      *params = (GLdouble) (ctx->Point.MaxSize);
  1556.      break;
  1557.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  1558.      *params = (GLdouble) (ctx->Point.Threshold);
  1559.      break;
  1560.       case GL_DISTANCE_ATTENUATION_EXT:
  1561.      params[0] = (GLdouble) (ctx->Point.Params[0]);
  1562.      params[1] = (GLdouble) (ctx->Point.Params[1]);
  1563.      params[2] = (GLdouble) (ctx->Point.Params[2]);
  1564.      break;
  1565.       case GL_POLYGON_MODE:
  1566.      params[0] = ENUM_TO_DOUBLE(ctx->Polygon.FrontMode);
  1567.      params[1] = ENUM_TO_DOUBLE(ctx->Polygon.BackMode);
  1568.      break;
  1569. #ifdef GL_EXT_polygon_offset
  1570.       case GL_POLYGON_OFFSET_BIAS_EXT:
  1571.          *params = (GLdouble) ctx->Polygon.OffsetUnits;
  1572.          break;
  1573. #endif
  1574.       case GL_POLYGON_OFFSET_FACTOR:
  1575.          *params = (GLdouble) ctx->Polygon.OffsetFactor;
  1576.          break;
  1577.       case GL_POLYGON_OFFSET_UNITS:
  1578.          *params = (GLdouble) ctx->Polygon.OffsetUnits;
  1579.          break;
  1580.       case GL_POLYGON_SMOOTH:
  1581.      *params = (GLdouble) ctx->Polygon.SmoothFlag;
  1582.      break;
  1583.       case GL_POLYGON_SMOOTH_HINT:
  1584.      *params = ENUM_TO_DOUBLE(ctx->Hint.PolygonSmooth);
  1585.      break;
  1586.       case GL_POLYGON_STIPPLE:
  1587.          *params = (GLdouble) ctx->Polygon.StippleFlag;
  1588.      break;
  1589.       case GL_PROJECTION_MATRIX:
  1590.      for (i=0;i<16;i++) {
  1591.         params[i] = (GLdouble) ctx->ProjectionMatrix[i];
  1592.      }
  1593.      break;
  1594.       case GL_PROJECTION_STACK_DEPTH:
  1595.      *params = (GLdouble) (ctx->ProjectionStackDepth + 1);
  1596.      break;
  1597.       case GL_READ_BUFFER:
  1598.      *params = ENUM_TO_DOUBLE(ctx->Pixel.ReadBuffer);
  1599.      break;
  1600.       case GL_RED_BIAS:
  1601.          *params = (GLdouble) ctx->Pixel.RedBias;
  1602.          break;
  1603.       case GL_RED_BITS:
  1604.          *params = (GLdouble) ctx->Visual->RedBits;
  1605.          break;
  1606.       case GL_RED_SCALE:
  1607.          *params = (GLdouble) ctx->Pixel.RedScale;
  1608.          break;
  1609.       case GL_RENDER_MODE:
  1610.      *params = ENUM_TO_DOUBLE(ctx->RenderMode);
  1611.      break;
  1612.       case GL_RGBA_MODE:
  1613.      *params = (GLdouble) ctx->Visual->RGBAflag;
  1614.      break;
  1615.       case GL_SCISSOR_BOX:
  1616.      params[0] = (GLdouble) ctx->Scissor.X;
  1617.      params[1] = (GLdouble) ctx->Scissor.Y;
  1618.      params[2] = (GLdouble) ctx->Scissor.Width;
  1619.      params[3] = (GLdouble) ctx->Scissor.Height;
  1620.      break;
  1621.       case GL_SCISSOR_TEST:
  1622.      *params = (GLdouble) ctx->Scissor.Enabled;
  1623.      break;
  1624.       case GL_SELECTION_BUFFER_SIZE:
  1625.          *params = (GLdouble) ctx->Select.BufferSize;
  1626.          break;
  1627.       case GL_SHADE_MODEL:
  1628.      *params = ENUM_TO_DOUBLE(ctx->Light.ShadeModel);
  1629.      break;
  1630.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  1631.          *params = (GLdouble) ctx->Texture.SharedPalette;
  1632.          break;
  1633.       case GL_STENCIL_BITS:
  1634.          *params = (GLdouble) ctx->Visual->StencilBits;
  1635.          break;
  1636.       case GL_STENCIL_CLEAR_VALUE:
  1637.      *params = (GLdouble) ctx->Stencil.Clear;
  1638.      break;
  1639.       case GL_STENCIL_FAIL:
  1640.      *params = ENUM_TO_DOUBLE(ctx->Stencil.FailFunc);
  1641.      break;
  1642.       case GL_STENCIL_FUNC:
  1643.      *params = ENUM_TO_DOUBLE(ctx->Stencil.Function);
  1644.      break;
  1645.       case GL_STENCIL_PASS_DEPTH_FAIL:
  1646.      *params = ENUM_TO_DOUBLE(ctx->Stencil.ZFailFunc);
  1647.      break;
  1648.       case GL_STENCIL_PASS_DEPTH_PASS:
  1649.      *params = ENUM_TO_DOUBLE(ctx->Stencil.ZPassFunc);
  1650.      break;
  1651.       case GL_STENCIL_REF:
  1652.      *params = (GLdouble) ctx->Stencil.Ref;
  1653.      break;
  1654.       case GL_STENCIL_TEST:
  1655.      *params = (GLdouble) ctx->Stencil.Enabled;
  1656.      break;
  1657.       case GL_STENCIL_VALUE_MASK:
  1658.      *params = (GLdouble) ctx->Stencil.ValueMask;
  1659.      break;
  1660.       case GL_STENCIL_WRITEMASK:
  1661.      *params = (GLdouble) ctx->Stencil.WriteMask;
  1662.      break;
  1663.       case GL_STEREO:
  1664.      *params = 0.0;   /* TODO */
  1665.      break;
  1666.       case GL_SUBPIXEL_BITS:
  1667.      *params = 0.0;   /* TODO */
  1668.      break;
  1669.       case GL_TEXTURE_1D:
  1670.          {
  1671.             GLuint bit = TEXTURE0_1D << (texSet * 4);
  1672.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  1673.          }
  1674.      break;
  1675.       case GL_TEXTURE_2D:
  1676.          {
  1677.             GLuint bit = TEXTURE0_2D << (texSet * 4);
  1678.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  1679.          }
  1680.      break;
  1681.       case GL_TEXTURE_3D:
  1682.          {
  1683.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  1684.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  1685.          }
  1686.      break;
  1687.       case GL_TEXTURE_BINDING_1D:
  1688.          *params = (GLdouble) textureSet->Current1D->Name;
  1689.           break;
  1690.       case GL_TEXTURE_BINDING_2D:
  1691.          *params = (GLdouble) textureSet->Current2D->Name;
  1692.           break;
  1693.       case GL_TEXTURE_BINDING_3D:
  1694.          *params = (GLdouble) textureSet->Current3D->Name;
  1695.           break;
  1696.       case GL_TEXTURE_ENV_COLOR:
  1697.      params[0] = (GLdouble) textureSet->EnvColor[0];
  1698.      params[1] = (GLdouble) textureSet->EnvColor[1];
  1699.      params[2] = (GLdouble) textureSet->EnvColor[2];
  1700.      params[3] = (GLdouble) textureSet->EnvColor[3];
  1701.      break;
  1702.       case GL_TEXTURE_ENV_MODE:
  1703.      *params = ENUM_TO_DOUBLE(textureSet->EnvMode);
  1704.      break;
  1705.       case GL_TEXTURE_GEN_S:
  1706.      *params = (textureSet->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
  1707.      break;
  1708.       case GL_TEXTURE_GEN_T:
  1709.      *params = (textureSet->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
  1710.      break;
  1711.       case GL_TEXTURE_GEN_R:
  1712.      *params = (textureSet->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
  1713.      break;
  1714.       case GL_TEXTURE_GEN_Q:
  1715.      *params = (textureSet->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
  1716.      break;
  1717.       case GL_TEXTURE_MATRIX:
  1718.          for (i=0;i<16;i++) {
  1719.         params[i] = (GLdouble) ctx->TextureMatrix[texTransformSet][i];
  1720.      }
  1721.      break;
  1722.       case GL_TEXTURE_STACK_DEPTH:
  1723.      *params = (GLdouble) (ctx->TextureStackDepth[texTransformSet] + 1);
  1724.      break;
  1725.       case GL_UNPACK_ALIGNMENT:
  1726.      *params = (GLdouble) ctx->Unpack.Alignment;
  1727.      break;
  1728.       case GL_UNPACK_LSB_FIRST:
  1729.      *params = (GLdouble) ctx->Unpack.LsbFirst;
  1730.      break;
  1731.       case GL_UNPACK_ROW_LENGTH:
  1732.      *params = (GLdouble) ctx->Unpack.RowLength;
  1733.      break;
  1734.       case GL_UNPACK_SKIP_PIXELS:
  1735.      *params = (GLdouble) ctx->Unpack.SkipPixels;
  1736.      break;
  1737.       case GL_UNPACK_SKIP_ROWS:
  1738.      *params = (GLdouble) ctx->Unpack.SkipRows;
  1739.      break;
  1740.       case GL_UNPACK_SWAP_BYTES:
  1741.      *params = (GLdouble) ctx->Unpack.SwapBytes;
  1742.      break;
  1743.       case GL_UNPACK_SKIP_IMAGES_EXT:
  1744.          *params = (GLdouble) ctx->Unpack.SkipImages;
  1745.          break;
  1746.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  1747.          *params = (GLdouble) ctx->Unpack.ImageHeight;
  1748.          break;
  1749.       case GL_VIEWPORT:
  1750.      params[0] = (GLdouble) ctx->Viewport.X;
  1751.      params[1] = (GLdouble) ctx->Viewport.Y;
  1752.      params[2] = (GLdouble) ctx->Viewport.Width;
  1753.      params[3] = (GLdouble) ctx->Viewport.Height;
  1754.      break;
  1755.       case GL_ZOOM_X:
  1756.      *params = (GLdouble) ctx->Pixel.ZoomX;
  1757.      break;
  1758.       case GL_ZOOM_Y:
  1759.      *params = (GLdouble) ctx->Pixel.ZoomY;
  1760.      break;
  1761.       case GL_VERTEX_ARRAY_SIZE:
  1762.          *params = (GLdouble) ctx->Array.VertexSize;
  1763.          break;
  1764.       case GL_VERTEX_ARRAY_TYPE:
  1765.          *params = ENUM_TO_DOUBLE(ctx->Array.VertexType);
  1766.          break;
  1767.       case GL_VERTEX_ARRAY_STRIDE:
  1768.          *params = (GLdouble) ctx->Array.VertexStride;
  1769.          break;
  1770.       case GL_VERTEX_ARRAY_COUNT_EXT:
  1771.          *params = 0.0;
  1772.          break;
  1773.       case GL_NORMAL_ARRAY_TYPE:
  1774.          *params = ENUM_TO_DOUBLE(ctx->Array.NormalType);
  1775.          break;
  1776.       case GL_NORMAL_ARRAY_STRIDE:
  1777.          *params = (GLdouble) ctx->Array.NormalStride;
  1778.          break;
  1779.       case GL_NORMAL_ARRAY_COUNT_EXT:
  1780.          *params = 0.0;
  1781.          break;
  1782.       case GL_COLOR_ARRAY_SIZE:
  1783.          *params = (GLdouble) ctx->Array.ColorSize;
  1784.          break;
  1785.       case GL_COLOR_ARRAY_TYPE:
  1786.          *params = ENUM_TO_DOUBLE(ctx->Array.ColorType);
  1787.          break;
  1788.       case GL_COLOR_ARRAY_STRIDE:
  1789.          *params = (GLdouble) ctx->Array.ColorStride;
  1790.          break;
  1791.       case GL_COLOR_ARRAY_COUNT_EXT:
  1792.          *params = 0.0;
  1793.          break;
  1794.       case GL_INDEX_ARRAY_TYPE:
  1795.          *params = ENUM_TO_DOUBLE(ctx->Array.IndexType);
  1796.          break;
  1797.       case GL_INDEX_ARRAY_STRIDE:
  1798.          *params = (GLdouble) ctx->Array.IndexStride;
  1799.          break;
  1800.       case GL_INDEX_ARRAY_COUNT_EXT:
  1801.          *params = 0.0;
  1802.          break;
  1803.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  1804.          *params = (GLdouble) ctx->Array.TexCoordSize[texSet];
  1805.          break;
  1806.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  1807.          *params = ENUM_TO_DOUBLE(ctx->Array.TexCoordType[texSet]);
  1808.          break;
  1809.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  1810.          *params = (GLdouble) ctx->Array.TexCoordStride[texSet];
  1811.          break;
  1812.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  1813.          *params = 0.0;
  1814.          break;
  1815.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  1816.          *params = (GLdouble) ctx->Array.EdgeFlagStride;
  1817.          break;
  1818.       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
  1819.          *params = 0.0;
  1820.          break;
  1821.  
  1822.       /* GL_SIGS_multitexture */
  1823.       case GL_SELECTED_TEXTURE_SGIS:
  1824.          *params = (GLdouble) ctx->Texture.CurrentSet;
  1825.          break;
  1826.       case GL_SELECTED_TEXTURE_COORD_SET_SGIS:
  1827.          *params = (GLdouble) ctx->TexCoordSet;
  1828.          break;
  1829.       case GL_MAX_TEXTURES_SGIS:
  1830.          *params = (GLdouble) max_textures(ctx);
  1831.          break;
  1832.  
  1833.       /* GL_EXT_multitexture */
  1834.       case GL_SELECTED_TEXTURE_EXT:
  1835.          *params = (GLdouble) ctx->Texture.CurrentSet;
  1836.          break;
  1837.       case GL_SELECTED_TEXTURE_COORD_SET_EXT:
  1838.          *params = (GLdouble) ctx->TexCoordSet;
  1839.          break;
  1840.       case GL_SELECTED_TEXTURE_TRANSFORM_EXT:
  1841.          *params = (GLdouble) ctx->Texture.CurrentTransformSet;
  1842.          break;
  1843.       case GL_MAX_TEXTURES_EXT:
  1844.          *params = (GLdouble) max_textures(ctx);
  1845.          break;
  1846.       case GL_MAX_TEXTURE_COORD_SETS_EXT:
  1847.          *params = (GLdouble) MAX_TEX_COORD_SETS;
  1848.          break;
  1849.  
  1850.       default:
  1851.          gl_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
  1852.    }
  1853. }
  1854.  
  1855.  
  1856.  
  1857.  
  1858. void gl_GetFloatv( GLcontext *ctx, GLenum pname, GLfloat *params )
  1859. {
  1860.    GLuint i;
  1861.    GLuint texSet = ctx->Texture.CurrentSet;
  1862.    GLuint texTransformSet = ctx->Texture.CurrentTransformSet;
  1863.    const struct gl_texture_set *textureSet = &ctx->Texture.Set[texSet];
  1864.  
  1865.    if (INSIDE_BEGIN_END(ctx)) {
  1866.       gl_error( ctx, GL_INVALID_OPERATION, "glGetFloatv" );
  1867.       return;
  1868.    }
  1869.    switch (pname) {
  1870.       case GL_ACCUM_RED_BITS:
  1871.       case GL_ACCUM_GREEN_BITS:
  1872.       case GL_ACCUM_BLUE_BITS:
  1873.       case GL_ACCUM_ALPHA_BITS:
  1874.          *params = (GLfloat) ctx->Visual->AccumBits;
  1875.          break;
  1876.       case GL_ACCUM_CLEAR_VALUE:
  1877.          params[0] = ctx->Accum.ClearColor[0];
  1878.          params[1] = ctx->Accum.ClearColor[1];
  1879.          params[2] = ctx->Accum.ClearColor[2];
  1880.          params[3] = ctx->Accum.ClearColor[3];
  1881.          break;
  1882.       case GL_ALPHA_BIAS:
  1883.          *params = ctx->Pixel.AlphaBias;
  1884.          break;
  1885.       case GL_ALPHA_BITS:
  1886.          *params = (GLfloat) ctx->Visual->AlphaBits;
  1887.          break;
  1888.       case GL_ALPHA_SCALE:
  1889.          *params = ctx->Pixel.AlphaScale;
  1890.          break;
  1891.       case GL_ALPHA_TEST:
  1892.          *params = (GLfloat) ctx->Color.AlphaEnabled;
  1893.          break;
  1894.       case GL_ALPHA_TEST_FUNC:
  1895.          *params = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
  1896.          break;
  1897.       case GL_ALPHA_TEST_REF:
  1898.          *params = (GLfloat) ctx->Color.AlphaRef / 255.0;
  1899.          break;
  1900.       case GL_ATTRIB_STACK_DEPTH:
  1901.          *params = (GLfloat) (ctx->AttribStackDepth);
  1902.          break;
  1903.       case GL_AUTO_NORMAL:
  1904.          *params = (GLfloat) ctx->Eval.AutoNormal;
  1905.          break;
  1906.       case GL_AUX_BUFFERS:
  1907.          *params = (GLfloat) NUM_AUX_BUFFERS;
  1908.          break;
  1909.       case GL_BLEND:
  1910.          *params = (GLfloat) ctx->Color.BlendEnabled;
  1911.          break;
  1912.       case GL_BLEND_DST:
  1913.          *params = ENUM_TO_FLOAT(ctx->Color.BlendDst);
  1914.          break;
  1915.       case GL_BLEND_SRC:
  1916.          *params = ENUM_TO_FLOAT(ctx->Color.BlendSrc);
  1917.          break;
  1918.       case GL_BLEND_EQUATION_EXT:
  1919.      *params = ENUM_TO_FLOAT(ctx->Color.BlendEquation);
  1920.      break;
  1921.       case GL_BLEND_COLOR_EXT:
  1922.      params[0] = ctx->Color.BlendColor[0];
  1923.      params[1] = ctx->Color.BlendColor[1];
  1924.      params[2] = ctx->Color.BlendColor[2];
  1925.      params[3] = ctx->Color.BlendColor[3];
  1926.      break;
  1927.       case GL_BLUE_BIAS:
  1928.          *params = ctx->Pixel.BlueBias;
  1929.          break;
  1930.       case GL_BLUE_BITS:
  1931.          *params = (GLfloat) ctx->Visual->BlueBits;
  1932.          break;
  1933.       case GL_BLUE_SCALE:
  1934.          *params = ctx->Pixel.BlueScale;
  1935.          break;
  1936.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  1937.          *params = (GLfloat) (ctx->ClientAttribStackDepth);
  1938.          break;
  1939.       case GL_CLIP_PLANE0:
  1940.       case GL_CLIP_PLANE1:
  1941.       case GL_CLIP_PLANE2:
  1942.       case GL_CLIP_PLANE3:
  1943.       case GL_CLIP_PLANE4:
  1944.       case GL_CLIP_PLANE5:
  1945.          *params = (GLfloat) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  1946.          break;
  1947.       case GL_COLOR_CLEAR_VALUE:
  1948.          params[0] = (GLfloat) ctx->Color.ClearColor[0];
  1949.          params[1] = (GLfloat) ctx->Color.ClearColor[1];
  1950.          params[2] = (GLfloat) ctx->Color.ClearColor[2];
  1951.          params[3] = (GLfloat) ctx->Color.ClearColor[3];
  1952.          break;
  1953.       case GL_COLOR_MATERIAL:
  1954.          *params = (GLfloat) ctx->Light.ColorMaterialEnabled;
  1955.          break;
  1956.       case GL_COLOR_MATERIAL_FACE:
  1957.          *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace);
  1958.          break;
  1959.       case GL_COLOR_MATERIAL_PARAMETER:
  1960.          *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode);
  1961.          break;
  1962.       case GL_COLOR_WRITEMASK:
  1963.          params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0F : 0.0F;
  1964.          params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0F : 0.0F;
  1965.          params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0F : 0.0F;
  1966.          params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0F : 0.0F;
  1967.          break;
  1968.       case GL_CULL_FACE:
  1969.          *params = (GLfloat) ctx->Polygon.CullFlag;
  1970.          break;
  1971.       case GL_CULL_FACE_MODE:
  1972.          *params = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
  1973.          break;
  1974.       case GL_CURRENT_COLOR:
  1975.          params[0] = (GLfloat) ctx->Current.ByteColor[0] / 255.0F;
  1976.          params[1] = (GLfloat) ctx->Current.ByteColor[1] / 255.0F;
  1977.          params[2] = (GLfloat) ctx->Current.ByteColor[2] / 255.0F;
  1978.          params[3] = (GLfloat) ctx->Current.ByteColor[3] / 255.0F;
  1979.          break;
  1980.       case GL_CURRENT_INDEX:
  1981.          *params = (GLfloat) ctx->Current.Index;
  1982.          break;
  1983.       case GL_CURRENT_NORMAL:
  1984.          params[0] = ctx->Current.Normal[0];
  1985.          params[1] = ctx->Current.Normal[1];
  1986.          params[2] = ctx->Current.Normal[2];
  1987.          break;
  1988.       case GL_CURRENT_RASTER_COLOR:
  1989.      params[0] = ctx->Current.RasterColor[0];
  1990.      params[1] = ctx->Current.RasterColor[1];
  1991.      params[2] = ctx->Current.RasterColor[2];
  1992.      params[3] = ctx->Current.RasterColor[3];
  1993.      break;
  1994.       case GL_CURRENT_RASTER_DISTANCE:
  1995.      params[0] = ctx->Current.RasterDistance;
  1996.      break;
  1997.       case GL_CURRENT_RASTER_INDEX:
  1998.      *params = (GLfloat) ctx->Current.RasterIndex;
  1999.      break;
  2000.       case GL_CURRENT_RASTER_POSITION:
  2001.      params[0] = ctx->Current.RasterPos[0];
  2002.      params[1] = ctx->Current.RasterPos[1];
  2003.      params[2] = ctx->Current.RasterPos[2];
  2004.      params[3] = ctx->Current.RasterPos[3];
  2005.      break;
  2006.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  2007.      params[0] = ctx->Current.RasterMultiTexCoord[texTransformSet][0];
  2008.      params[1] = ctx->Current.RasterMultiTexCoord[texTransformSet][1];
  2009.      params[2] = ctx->Current.RasterMultiTexCoord[texTransformSet][2];
  2010.      params[3] = ctx->Current.RasterMultiTexCoord[texTransformSet][3];
  2011.      break;
  2012.       case GL_CURRENT_RASTER_POSITION_VALID:
  2013.      *params = (GLfloat) ctx->Current.RasterPosValid;
  2014.      break;
  2015.       case GL_CURRENT_TEXTURE_COORDS:
  2016.      params[0] = (GLfloat) ctx->Current.MultiTexCoord[texTransformSet][0];
  2017.      params[1] = (GLfloat) ctx->Current.MultiTexCoord[texTransformSet][1];
  2018.      params[2] = (GLfloat) ctx->Current.MultiTexCoord[texTransformSet][2];
  2019.      params[3] = (GLfloat) ctx->Current.MultiTexCoord[texTransformSet][3];
  2020.      break;
  2021.       case GL_DEPTH_BIAS:
  2022.      *params = (GLfloat) ctx->Pixel.DepthBias;
  2023.      break;
  2024.       case GL_DEPTH_BITS:
  2025.      *params = (GLfloat) ctx->Visual->DepthBits;
  2026.      break;
  2027.       case GL_DEPTH_CLEAR_VALUE:
  2028.      *params = (GLfloat) ctx->Depth.Clear;
  2029.      break;
  2030.       case GL_DEPTH_FUNC:
  2031.      *params = ENUM_TO_FLOAT(ctx->Depth.Func);
  2032.      break;
  2033.       case GL_DEPTH_RANGE:
  2034.          params[0] = (GLfloat) ctx->Viewport.Near;
  2035.          params[1] = (GLfloat) ctx->Viewport.Far;
  2036.      break;
  2037.       case GL_DEPTH_SCALE:
  2038.      *params = (GLfloat) ctx->Pixel.DepthScale;
  2039.      break;
  2040.       case GL_DEPTH_TEST:
  2041.      *params = (GLfloat) ctx->Depth.Test;
  2042.      break;
  2043.       case GL_DEPTH_WRITEMASK:
  2044.      *params = (GLfloat) ctx->Depth.Mask;
  2045.      break;
  2046.       case GL_DITHER:
  2047.      *params = (GLfloat) ctx->Color.DitherFlag;
  2048.      break;
  2049.       case GL_DOUBLEBUFFER:
  2050.      *params = (GLfloat) ctx->Visual->DBflag;
  2051.      break;
  2052.       case GL_DRAW_BUFFER:
  2053.      *params = ENUM_TO_FLOAT(ctx->Color.DrawBuffer);
  2054.      break;
  2055.       case GL_EDGE_FLAG:
  2056.      *params = (GLfloat) ctx->Current.EdgeFlag;
  2057.      break;
  2058.       case GL_FEEDBACK_BUFFER_SIZE:
  2059.          /* TODO: is this right?  Or, return number of entries in buffer? */
  2060.          *params = (GLfloat) ctx->Feedback.BufferSize;
  2061.          break;
  2062.       case GL_FEEDBACK_BUFFER_TYPE:
  2063.          *params = ENUM_TO_FLOAT(ctx->Feedback.Type);
  2064.          break;
  2065.       case GL_FOG:
  2066.      *params = (GLfloat) ctx->Fog.Enabled;
  2067.      break;
  2068.       case GL_FOG_COLOR:
  2069.      params[0] = ctx->Fog.Color[0];
  2070.      params[1] = ctx->Fog.Color[1];
  2071.      params[2] = ctx->Fog.Color[2];
  2072.      params[3] = ctx->Fog.Color[3];
  2073.      break;
  2074.       case GL_FOG_DENSITY:
  2075.      *params = ctx->Fog.Density;
  2076.      break;
  2077.       case GL_FOG_END:
  2078.      *params = ctx->Fog.End;
  2079.      break;
  2080.       case GL_FOG_HINT:
  2081.      *params = ENUM_TO_FLOAT(ctx->Hint.Fog);
  2082.      break;
  2083.       case GL_FOG_INDEX:
  2084.      *params = ctx->Fog.Index;
  2085.      break;
  2086.       case GL_FOG_MODE:
  2087.      *params = ENUM_TO_FLOAT(ctx->Fog.Mode);
  2088.      break;
  2089.       case GL_FOG_START:
  2090.      *params = ctx->Fog.Start;
  2091.      break;
  2092.       case GL_FRONT_FACE:
  2093.      *params = ENUM_TO_FLOAT(ctx->Polygon.FrontFace);
  2094.      break;
  2095.       case GL_GREEN_BIAS:
  2096.          *params = (GLfloat) ctx->Pixel.GreenBias;
  2097.          break;
  2098.       case GL_GREEN_BITS:
  2099.          *params = (GLfloat) ctx->Visual->GreenBits;
  2100.          break;
  2101.       case GL_GREEN_SCALE:
  2102.          *params = (GLfloat) ctx->Pixel.GreenScale;
  2103.          break;
  2104.       case GL_INDEX_BITS:
  2105.          *params = (GLfloat) ctx->Visual->IndexBits;
  2106.      break;
  2107.       case GL_INDEX_CLEAR_VALUE:
  2108.          *params = (GLfloat) ctx->Color.ClearIndex;
  2109.      break;
  2110.       case GL_INDEX_MODE:
  2111.      *params = ctx->Visual->RGBAflag ? 0.0F : 1.0F;
  2112.      break;
  2113.       case GL_INDEX_OFFSET:
  2114.      *params = (GLfloat) ctx->Pixel.IndexOffset;
  2115.      break;
  2116.       case GL_INDEX_SHIFT:
  2117.      *params = (GLfloat) ctx->Pixel.IndexShift;
  2118.      break;
  2119.       case GL_INDEX_WRITEMASK:
  2120.      *params = (GLfloat) ctx->Color.IndexMask;
  2121.      break;
  2122.       case GL_LIGHT0:
  2123.       case GL_LIGHT1:
  2124.       case GL_LIGHT2:
  2125.       case GL_LIGHT3:
  2126.       case GL_LIGHT4:
  2127.       case GL_LIGHT5:
  2128.       case GL_LIGHT6:
  2129.       case GL_LIGHT7:
  2130.      *params = (GLfloat) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  2131.      break;
  2132.       case GL_LIGHTING:
  2133.      *params = (GLfloat) ctx->Light.Enabled;
  2134.      break;
  2135.       case GL_LIGHT_MODEL_AMBIENT:
  2136.      params[0] = ctx->Light.Model.Ambient[0];
  2137.      params[1] = ctx->Light.Model.Ambient[1];
  2138.      params[2] = ctx->Light.Model.Ambient[2];
  2139.      params[3] = ctx->Light.Model.Ambient[3];
  2140.      break;
  2141.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  2142.          params[0] = ENUM_TO_FLOAT(ctx->Light.Model.ColorControl);
  2143.          break;
  2144.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  2145.      *params = (GLfloat) ctx->Light.Model.LocalViewer;
  2146.      break;
  2147.       case GL_LIGHT_MODEL_TWO_SIDE:
  2148.      *params = (GLfloat) ctx->Light.Model.TwoSide;
  2149.      break;
  2150.       case GL_LINE_SMOOTH:
  2151.      *params = (GLfloat) ctx->Line.SmoothFlag;
  2152.      break;
  2153.       case GL_LINE_SMOOTH_HINT:
  2154.      *params = ENUM_TO_FLOAT(ctx->Hint.LineSmooth);
  2155.      break;
  2156.       case GL_LINE_STIPPLE:
  2157.      *params = (GLfloat) ctx->Line.StippleFlag;
  2158.      break;
  2159.       case GL_LINE_STIPPLE_PATTERN:
  2160.          *params = (GLfloat) ctx->Line.StipplePattern;
  2161.          break;
  2162.       case GL_LINE_STIPPLE_REPEAT:
  2163.          *params = (GLfloat) ctx->Line.StippleFactor;
  2164.          break;
  2165.       case GL_LINE_WIDTH:
  2166.      *params = (GLfloat) ctx->Line.Width;
  2167.      break;
  2168.       case GL_LINE_WIDTH_GRANULARITY:
  2169.      *params = (GLfloat) LINE_WIDTH_GRANULARITY;
  2170.      break;
  2171.       case GL_LINE_WIDTH_RANGE:
  2172.      params[0] = (GLfloat) MIN_LINE_WIDTH;
  2173.      params[1] = (GLfloat) MAX_LINE_WIDTH;
  2174.      break;
  2175.       case GL_LIST_BASE:
  2176.      *params = (GLfloat) ctx->List.ListBase;
  2177.      break;
  2178.       case GL_LIST_INDEX:
  2179.      *params = (GLfloat) ctx->CurrentListNum;
  2180.      break;
  2181.       case GL_LIST_MODE:
  2182.      *params = ctx->ExecuteFlag ? ENUM_TO_FLOAT(GL_COMPILE_AND_EXECUTE)
  2183.                      : ENUM_TO_FLOAT(GL_COMPILE);
  2184.      break;
  2185.       case GL_INDEX_LOGIC_OP:
  2186.      *params = (GLfloat) ctx->Color.IndexLogicOpEnabled;
  2187.      break;
  2188.       case GL_COLOR_LOGIC_OP:
  2189.      *params = (GLfloat) ctx->Color.ColorLogicOpEnabled;
  2190.      break;
  2191.       case GL_LOGIC_OP_MODE:
  2192.          *params = ENUM_TO_FLOAT(ctx->Color.LogicOp);
  2193.      break;
  2194.       case GL_MAP1_COLOR_4:
  2195.      *params = (GLfloat) ctx->Eval.Map1Color4;
  2196.      break;
  2197.       case GL_MAP1_GRID_DOMAIN:
  2198.      params[0] = ctx->Eval.MapGrid1u1;
  2199.      params[1] = ctx->Eval.MapGrid1u2;
  2200.      break;
  2201.       case GL_MAP1_GRID_SEGMENTS:
  2202.      *params = (GLfloat) ctx->Eval.MapGrid1un;
  2203.      break;
  2204.       case GL_MAP1_INDEX:
  2205.      *params = (GLfloat) ctx->Eval.Map1Index;
  2206.      break;
  2207.       case GL_MAP1_NORMAL:
  2208.      *params = (GLfloat) ctx->Eval.Map1Normal;
  2209.      break;
  2210.       case GL_MAP1_TEXTURE_COORD_1:
  2211.      *params = (GLfloat) ctx->Eval.Map1TextureCoord1;
  2212.      break;
  2213.       case GL_MAP1_TEXTURE_COORD_2:
  2214.      *params = (GLfloat) ctx->Eval.Map1TextureCoord2;
  2215.      break;
  2216.       case GL_MAP1_TEXTURE_COORD_3:
  2217.      *params = (GLfloat) ctx->Eval.Map1TextureCoord3;
  2218.      break;
  2219.       case GL_MAP1_TEXTURE_COORD_4:
  2220.      *params = (GLfloat) ctx->Eval.Map1TextureCoord4;
  2221.      break;
  2222.       case GL_MAP1_VERTEX_3:
  2223.      *params = (GLfloat) ctx->Eval.Map1Vertex3;
  2224.      break;
  2225.       case GL_MAP1_VERTEX_4:
  2226.      *params = (GLfloat) ctx->Eval.Map1Vertex4;
  2227.      break;
  2228.       case GL_MAP2_COLOR_4:
  2229.      *params = (GLfloat) ctx->Eval.Map2Color4;
  2230.      break;
  2231.       case GL_MAP2_GRID_DOMAIN:
  2232.      params[0] = ctx->Eval.MapGrid2u1;
  2233.      params[1] = ctx->Eval.MapGrid2u2;
  2234.      params[2] = ctx->Eval.MapGrid2v1;
  2235.      params[3] = ctx->Eval.MapGrid2v2;
  2236.      break;
  2237.       case GL_MAP2_GRID_SEGMENTS:
  2238.      params[0] = (GLfloat) ctx->Eval.MapGrid2un;
  2239.      params[1] = (GLfloat) ctx->Eval.MapGrid2vn;
  2240.      break;
  2241.       case GL_MAP2_INDEX:
  2242.      *params = (GLfloat) ctx->Eval.Map2Index;
  2243.      break;
  2244.       case GL_MAP2_NORMAL:
  2245.      *params = (GLfloat) ctx->Eval.Map2Normal;
  2246.      break;
  2247.       case GL_MAP2_TEXTURE_COORD_1:
  2248.      *params = ctx->Eval.Map2TextureCoord1;
  2249.      break;
  2250.       case GL_MAP2_TEXTURE_COORD_2:
  2251.      *params = ctx->Eval.Map2TextureCoord2;
  2252.      break;
  2253.       case GL_MAP2_TEXTURE_COORD_3:
  2254.      *params = ctx->Eval.Map2TextureCoord3;
  2255.      break;
  2256.       case GL_MAP2_TEXTURE_COORD_4:
  2257.      *params = ctx->Eval.Map2TextureCoord4;
  2258.      break;
  2259.       case GL_MAP2_VERTEX_3:
  2260.      *params = (GLfloat) ctx->Eval.Map2Vertex3;
  2261.      break;
  2262.       case GL_MAP2_VERTEX_4:
  2263.      *params = (GLfloat) ctx->Eval.Map2Vertex4;
  2264.      break;
  2265.       case GL_MAP_COLOR:
  2266.      *params = (GLfloat) ctx->Pixel.MapColorFlag;
  2267.      break;
  2268.       case GL_MAP_STENCIL:
  2269.      *params = (GLfloat) ctx->Pixel.MapStencilFlag;
  2270.      break;
  2271.       case GL_MATRIX_MODE:
  2272.      *params = ENUM_TO_FLOAT(ctx->Transform.MatrixMode);
  2273.      break;
  2274.       case GL_MAX_ATTRIB_STACK_DEPTH:
  2275.      *params = (GLfloat) MAX_ATTRIB_STACK_DEPTH;
  2276.      break;
  2277.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  2278.          *params = (GLfloat) MAX_CLIENT_ATTRIB_STACK_DEPTH;
  2279.          break;
  2280.       case GL_MAX_CLIP_PLANES:
  2281.      *params = (GLfloat) MAX_CLIP_PLANES;
  2282.      break;
  2283.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  2284.          *params = (GLfloat) VB_MAX;
  2285.          break;
  2286.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  2287.          *params = (GLfloat) VB_MAX;
  2288.          break;
  2289.       case GL_MAX_EVAL_ORDER:
  2290.      *params = (GLfloat) MAX_EVAL_ORDER;
  2291.      break;
  2292.       case GL_MAX_LIGHTS:
  2293.      *params = (GLfloat) MAX_LIGHTS;
  2294.      break;
  2295.       case GL_MAX_LIST_NESTING:
  2296.      *params = (GLfloat) MAX_LIST_NESTING;
  2297.      break;
  2298.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  2299.      *params = (GLfloat) MAX_MODELVIEW_STACK_DEPTH;
  2300.      break;
  2301.       case GL_MAX_NAME_STACK_DEPTH:
  2302.      *params = (GLfloat) MAX_NAME_STACK_DEPTH;
  2303.      break;
  2304.       case GL_MAX_PIXEL_MAP_TABLE:
  2305.      *params = (GLfloat) MAX_PIXEL_MAP_TABLE;
  2306.      break;
  2307.       case GL_MAX_PROJECTION_STACK_DEPTH:
  2308.      *params = (GLfloat) MAX_PROJECTION_STACK_DEPTH;
  2309.      break;
  2310.       case GL_MAX_TEXTURE_SIZE:
  2311.       case GL_MAX_3D_TEXTURE_SIZE:
  2312.          *params = (GLfloat) max_texture_size(ctx);
  2313.      break;
  2314.       case GL_MAX_TEXTURE_STACK_DEPTH:
  2315.      *params = (GLfloat) MAX_TEXTURE_STACK_DEPTH;
  2316.      break;
  2317.       case GL_MAX_VIEWPORT_DIMS:
  2318.          params[0] = (GLfloat) MAX_WIDTH;
  2319.          params[1] = (GLfloat) MAX_HEIGHT;
  2320.          break;
  2321.       case GL_MODELVIEW_MATRIX:
  2322.      for (i=0;i<16;i++) {
  2323.         params[i] = ctx->ModelViewMatrix[i];
  2324.      }
  2325.      break;
  2326.       case GL_MODELVIEW_STACK_DEPTH:
  2327.      *params = (GLfloat) (ctx->ModelViewStackDepth + 1);
  2328.      break;
  2329.       case GL_NAME_STACK_DEPTH:
  2330.      *params = (GLfloat) ctx->Select.NameStackDepth;
  2331.      break;
  2332.       case GL_NORMALIZE:
  2333.      *params = (GLfloat) ctx->Transform.Normalize;
  2334.      break;
  2335.       case GL_PACK_ALIGNMENT:
  2336.      *params = (GLfloat) ctx->Pack.Alignment;
  2337.      break;
  2338.       case GL_PACK_LSB_FIRST:
  2339.      *params = (GLfloat) ctx->Pack.LsbFirst;
  2340.      break;
  2341.       case GL_PACK_ROW_LENGTH:
  2342.      *params = (GLfloat) ctx->Pack.RowLength;
  2343.      break;
  2344.       case GL_PACK_SKIP_PIXELS:
  2345.      *params = (GLfloat) ctx->Pack.SkipPixels;
  2346.      break;
  2347.       case GL_PACK_SKIP_ROWS:
  2348.      *params = (GLfloat) ctx->Pack.SkipRows;
  2349.      break;
  2350.       case GL_PACK_SWAP_BYTES:
  2351.      *params = (GLfloat) ctx->Pack.SwapBytes;
  2352.      break;
  2353.       case GL_PACK_SKIP_IMAGES_EXT:
  2354.          *params = (GLfloat) ctx->Pack.SkipImages;
  2355.          break;
  2356.       case GL_PACK_IMAGE_HEIGHT_EXT:
  2357.          *params = (GLfloat) ctx->Pack.ImageHeight;
  2358.          break;
  2359.       case GL_PERSPECTIVE_CORRECTION_HINT:
  2360.      *params = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
  2361.      break;
  2362.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  2363.      *params = (GLfloat) ctx->Pixel.MapAtoAsize;
  2364.      break;
  2365.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  2366.      *params = (GLfloat) ctx->Pixel.MapBtoBsize;
  2367.      break;
  2368.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  2369.      *params = (GLfloat) ctx->Pixel.MapGtoGsize;
  2370.      break;
  2371.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  2372.      *params = (GLfloat) ctx->Pixel.MapItoAsize;
  2373.      break;
  2374.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  2375.      *params = (GLfloat) ctx->Pixel.MapItoBsize;
  2376.      break;
  2377.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  2378.      *params = (GLfloat) ctx->Pixel.MapItoGsize;
  2379.      break;
  2380.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  2381.      *params = (GLfloat) ctx->Pixel.MapItoIsize;
  2382.      break;
  2383.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  2384.      *params = (GLfloat) ctx->Pixel.MapItoRsize;
  2385.      break;
  2386.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  2387.      *params = (GLfloat) ctx->Pixel.MapRtoRsize;
  2388.      break;
  2389.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  2390.      *params = (GLfloat) ctx->Pixel.MapStoSsize;
  2391.      break;
  2392.       case GL_POINT_SIZE:
  2393.          *params = (GLfloat) ctx->Point.Size;
  2394.          break;
  2395.       case GL_POINT_SIZE_GRANULARITY:
  2396.      *params = (GLfloat) POINT_SIZE_GRANULARITY;
  2397.      break;
  2398.       case GL_POINT_SIZE_RANGE:
  2399.      params[0] = (GLfloat) MIN_POINT_SIZE;
  2400.      params[1] = (GLfloat) MAX_POINT_SIZE;
  2401.      break;
  2402.       case GL_POINT_SMOOTH:
  2403.      *params = (GLfloat) ctx->Point.SmoothFlag;
  2404.      break;
  2405.       case GL_POINT_SMOOTH_HINT:
  2406.      *params = ENUM_TO_FLOAT(ctx->Hint.PointSmooth);
  2407.      break;
  2408.       case GL_POINT_SIZE_MIN_EXT:
  2409.      *params = (GLfloat) (ctx->Point.MinSize);
  2410.      break;
  2411.       case GL_POINT_SIZE_MAX_EXT:
  2412.      *params = (GLfloat) (ctx->Point.MaxSize);
  2413.      break;
  2414.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  2415.      *params = (GLfloat) (ctx->Point.Threshold);
  2416.      break;
  2417.       case GL_DISTANCE_ATTENUATION_EXT:
  2418.      params[0] = (GLfloat) (ctx->Point.Params[0]);
  2419.      params[1] = (GLfloat) (ctx->Point.Params[1]);
  2420.      params[2] = (GLfloat) (ctx->Point.Params[2]);
  2421.      break;
  2422.       case GL_POLYGON_MODE:
  2423.      params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode);
  2424.      params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode);
  2425.      break;
  2426. #ifdef GL_EXT_polygon_offset
  2427.       case GL_POLYGON_OFFSET_BIAS_EXT:
  2428.          *params = ctx->Polygon.OffsetUnits;
  2429.          break;
  2430. #endif
  2431.       case GL_POLYGON_OFFSET_FACTOR:
  2432.          *params = ctx->Polygon.OffsetFactor;
  2433.          break;
  2434.       case GL_POLYGON_OFFSET_UNITS:
  2435.          *params = ctx->Polygon.OffsetUnits;
  2436.          break;
  2437.       case GL_POLYGON_SMOOTH:
  2438.      *params = (GLfloat) ctx->Polygon.SmoothFlag;
  2439.      break;
  2440.       case GL_POLYGON_SMOOTH_HINT:
  2441.      *params = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth);
  2442.      break;
  2443.       case GL_POLYGON_STIPPLE:
  2444.          *params = (GLfloat) ctx->Polygon.StippleFlag;
  2445.      break;
  2446.       case GL_PROJECTION_MATRIX:
  2447.      for (i=0;i<16;i++) {
  2448.         params[i] = ctx->ProjectionMatrix[i];
  2449.      }
  2450.      break;
  2451.       case GL_PROJECTION_STACK_DEPTH:
  2452.      *params = (GLfloat) (ctx->ProjectionStackDepth + 1);
  2453.      break;
  2454.       case GL_READ_BUFFER:
  2455.      *params = ENUM_TO_FLOAT(ctx->Pixel.ReadBuffer);
  2456.      break;
  2457.       case GL_RED_BIAS:
  2458.          *params = ctx->Pixel.RedBias;
  2459.          break;
  2460.       case GL_RED_BITS:
  2461.          *params = (GLfloat) ctx->Visual->RedBits;
  2462.          break;
  2463.       case GL_RED_SCALE:
  2464.          *params = ctx->Pixel.RedScale;
  2465.          break;
  2466.       case GL_RENDER_MODE:
  2467.      *params = ENUM_TO_FLOAT(ctx->RenderMode);
  2468.      break;
  2469.       case GL_RGBA_MODE:
  2470.      *params = (GLfloat) ctx->Visual->RGBAflag;
  2471.      break;
  2472.       case GL_SCISSOR_BOX:
  2473.      params[0] = (GLfloat) ctx->Scissor.X;
  2474.      params[1] = (GLfloat) ctx->Scissor.Y;
  2475.      params[2] = (GLfloat) ctx->Scissor.Width;
  2476.      params[3] = (GLfloat) ctx->Scissor.Height;
  2477.      break;
  2478.       case GL_SCISSOR_TEST:
  2479.      *params = (GLfloat) ctx->Scissor.Enabled;
  2480.      break;
  2481.       case GL_SELECTION_BUFFER_SIZE:
  2482.          *params = (GLfloat) ctx->Select.BufferSize;
  2483.          break;
  2484.       case GL_SHADE_MODEL:
  2485.      *params = ENUM_TO_FLOAT(ctx->Light.ShadeModel);
  2486.      break;
  2487.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  2488.          *params = (GLfloat) ctx->Texture.SharedPalette;
  2489.          break;
  2490.       case GL_STENCIL_BITS:
  2491.          *params = (GLfloat) ctx->Visual->StencilBits;
  2492.          break;
  2493.       case GL_STENCIL_CLEAR_VALUE:
  2494.      *params = (GLfloat) ctx->Stencil.Clear;
  2495.      break;
  2496.       case GL_STENCIL_FAIL:
  2497.      *params = ENUM_TO_FLOAT(ctx->Stencil.FailFunc);
  2498.      break;
  2499.       case GL_STENCIL_FUNC:
  2500.      *params = ENUM_TO_FLOAT(ctx->Stencil.Function);
  2501.      break;
  2502.       case GL_STENCIL_PASS_DEPTH_FAIL:
  2503.      *params = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc);
  2504.      break;
  2505.       case GL_STENCIL_PASS_DEPTH_PASS:
  2506.      *params = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc);
  2507.      break;
  2508.       case GL_STENCIL_REF:
  2509.      *params = (GLfloat) ctx->Stencil.Ref;
  2510.      break;
  2511.       case GL_STENCIL_TEST:
  2512.      *params = (GLfloat) ctx->Stencil.Enabled;
  2513.      break;
  2514.       case GL_STENCIL_VALUE_MASK:
  2515.      *params = (GLfloat) ctx->Stencil.ValueMask;
  2516.      break;
  2517.       case GL_STENCIL_WRITEMASK:
  2518.      *params = (GLfloat) ctx->Stencil.WriteMask;
  2519.      break;
  2520.       case GL_STEREO:
  2521.      *params = 0.0F;  /* TODO */
  2522.      break;
  2523.       case GL_SUBPIXEL_BITS:
  2524.      *params = 0.0F;  /* TODO */
  2525.      break;
  2526.       case GL_TEXTURE_1D:
  2527.          {
  2528.             GLuint bit = TEXTURE0_1D << (texSet * 4);
  2529.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  2530.          }
  2531.      break;
  2532.       case GL_TEXTURE_2D:
  2533.          {
  2534.             GLuint bit = TEXTURE0_2D << (texSet * 4);
  2535.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  2536.          }
  2537.      break;
  2538.       case GL_TEXTURE_3D:
  2539.          {
  2540.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  2541.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  2542.          }
  2543.      break;
  2544.       case GL_TEXTURE_BINDING_1D:
  2545.          *params = (GLfloat) textureSet->Current1D->Name;
  2546.           break;
  2547.       case GL_TEXTURE_BINDING_2D:
  2548.          *params = (GLfloat) textureSet->Current2D->Name;
  2549.           break;
  2550.       case GL_TEXTURE_BINDING_3D:
  2551.          *params = (GLfloat) textureSet->Current2D->Name;
  2552.           break;
  2553.       case GL_TEXTURE_ENV_COLOR:
  2554.      params[0] = textureSet->EnvColor[0];
  2555.      params[1] = textureSet->EnvColor[1];
  2556.      params[2] = textureSet->EnvColor[2];
  2557.      params[3] = textureSet->EnvColor[3];
  2558.      break;
  2559.       case GL_TEXTURE_ENV_MODE:
  2560.      *params = ENUM_TO_FLOAT(textureSet->EnvMode);
  2561.      break;
  2562.       case GL_TEXTURE_GEN_S:
  2563.      *params = (textureSet->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
  2564.      break;
  2565.       case GL_TEXTURE_GEN_T:
  2566.      *params = (textureSet->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
  2567.      break;
  2568.       case GL_TEXTURE_GEN_R:
  2569.      *params = (textureSet->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
  2570.      break;
  2571.       case GL_TEXTURE_GEN_Q:
  2572.      *params = (textureSet->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
  2573.      break;
  2574.       case GL_TEXTURE_MATRIX:
  2575.          for (i=0;i<16;i++) {
  2576.         params[i] = ctx->TextureMatrix[texTransformSet][i];
  2577.      }
  2578.      break;
  2579.       case GL_TEXTURE_STACK_DEPTH:
  2580.      *params = (GLfloat) (ctx->TextureStackDepth[texTransformSet] + 1);
  2581.      break;
  2582.       case GL_UNPACK_ALIGNMENT:
  2583.      *params = (GLfloat) ctx->Unpack.Alignment;
  2584.      break;
  2585.       case GL_UNPACK_LSB_FIRST:
  2586.      *params = (GLfloat) ctx->Unpack.LsbFirst;
  2587.      break;
  2588.       case GL_UNPACK_ROW_LENGTH:
  2589.      *params = (GLfloat) ctx->Unpack.RowLength;
  2590.      break;
  2591.       case GL_UNPACK_SKIP_PIXELS:
  2592.      *params = (GLfloat) ctx->Unpack.SkipPixels;
  2593.      break;
  2594.       case GL_UNPACK_SKIP_ROWS:
  2595.      *params = (GLfloat) ctx->Unpack.SkipRows;
  2596.      break;
  2597.       case GL_UNPACK_SWAP_BYTES:
  2598.      *params = (GLfloat) ctx->Unpack.SwapBytes;
  2599.      break;
  2600.       case GL_UNPACK_SKIP_IMAGES_EXT:
  2601.          *params = (GLfloat) ctx->Unpack.SkipImages;
  2602.          break;
  2603.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  2604.          *params = (GLfloat) ctx->Unpack.ImageHeight;
  2605.          break;
  2606.       case GL_VIEWPORT:
  2607.      params[0] = (GLfloat) ctx->Viewport.X;
  2608.      params[1] = (GLfloat) ctx->Viewport.Y;
  2609.      params[2] = (GLfloat) ctx->Viewport.Width;
  2610.      params[3] = (GLfloat) ctx->Viewport.Height;
  2611.      break;
  2612.       case GL_ZOOM_X:
  2613.      *params = (GLfloat) ctx->Pixel.ZoomX;
  2614.      break;
  2615.       case GL_ZOOM_Y:
  2616.      *params = (GLfloat) ctx->Pixel.ZoomY;
  2617.      break;
  2618.       case GL_VERTEX_ARRAY_SIZE:
  2619.          *params = (GLfloat) ctx->Array.VertexSize;
  2620.          break;
  2621.       case GL_VERTEX_ARRAY_TYPE:
  2622.          *params = ENUM_TO_FLOAT(ctx->Array.VertexType);
  2623.          break;
  2624.       case GL_VERTEX_ARRAY_STRIDE:
  2625.          *params = (GLfloat) ctx->Array.VertexStride;
  2626.          break;
  2627.       case GL_VERTEX_ARRAY_COUNT_EXT:
  2628.          *params = 0.0;
  2629.          break;
  2630.       case GL_NORMAL_ARRAY_TYPE:
  2631.          *params = ENUM_TO_FLOAT(ctx->Array.NormalType);
  2632.          break;
  2633.       case GL_NORMAL_ARRAY_STRIDE:
  2634.          *params = (GLfloat) ctx->Array.NormalStride;
  2635.          break;
  2636.       case GL_NORMAL_ARRAY_COUNT_EXT:
  2637.          *params = 0.0;
  2638.          break;
  2639.       case GL_COLOR_ARRAY_SIZE:
  2640.          *params = (GLfloat) ctx->Array.ColorSize;
  2641.          break;
  2642.       case GL_COLOR_ARRAY_TYPE:
  2643.          *params = ENUM_TO_FLOAT(ctx->Array.ColorType);
  2644.          break;
  2645.       case GL_COLOR_ARRAY_STRIDE:
  2646.          *params = (GLfloat) ctx->Array.ColorStride;
  2647.          break;
  2648.       case GL_COLOR_ARRAY_COUNT_EXT:
  2649.          *params = 0.0;
  2650.          break;
  2651.       case GL_INDEX_ARRAY_TYPE:
  2652.          *params = ENUM_TO_FLOAT(ctx->Array.IndexType);
  2653.          break;
  2654.       case GL_INDEX_ARRAY_STRIDE:
  2655.          *params = (GLfloat) ctx->Array.IndexStride;
  2656.          break;
  2657.       case GL_INDEX_ARRAY_COUNT_EXT:
  2658.          *params = 0.0;
  2659.          break;
  2660.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  2661.          *params = (GLfloat) ctx->Array.TexCoordSize[texSet];
  2662.          break;
  2663.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  2664.          *params = ENUM_TO_FLOAT(ctx->Array.TexCoordType[texSet]);
  2665.          break;
  2666.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  2667.          *params = (GLfloat) ctx->Array.TexCoordStride[texSet];
  2668.          break;
  2669.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  2670.          *params = 0.0;
  2671.          break;
  2672.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  2673.          *params = (GLfloat) ctx->Array.EdgeFlagStride;
  2674.          break;
  2675.       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
  2676.          *params = 0.0;
  2677.          break;
  2678.  
  2679.       /* GL_SGIS_multitexture */
  2680.       case GL_SELECTED_TEXTURE_SGIS:
  2681.          *params = (GLfloat) ctx->Texture.CurrentSet;
  2682.          break;
  2683.       case GL_SELECTED_TEXTURE_COORD_SET_SGIS:
  2684.          *params = (GLfloat) ctx->TexCoordSet;
  2685.          break;
  2686.       case GL_MAX_TEXTURES_SGIS:
  2687.          *params = (GLfloat) max_textures(ctx);
  2688.          break;
  2689.  
  2690.       /* GL_EXT_multitexture */
  2691.       case GL_SELECTED_TEXTURE_EXT:
  2692.          *params = (GLfloat) ctx->Texture.CurrentSet;
  2693.          break;
  2694.       case GL_SELECTED_TEXTURE_COORD_SET_EXT:
  2695.          *params = (GLfloat) ctx->TexCoordSet;
  2696.          break;
  2697.       case GL_SELECTED_TEXTURE_TRANSFORM_EXT:
  2698.          *params = (GLfloat) ctx->Texture.CurrentTransformSet;
  2699.          break;
  2700.       case GL_MAX_TEXTURES_EXT:
  2701.          *params = (GLfloat) max_textures(ctx);
  2702.          break;
  2703.       case GL_MAX_TEXTURE_COORD_SETS_EXT:
  2704.          *params = (GLfloat) MAX_TEX_COORD_SETS;
  2705.          break;
  2706.  
  2707.       default:
  2708.          gl_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
  2709.    }
  2710. }
  2711.  
  2712.  
  2713.  
  2714.  
  2715. void gl_GetIntegerv( GLcontext *ctx, GLenum pname, GLint *params )
  2716. {
  2717.    GLuint i;
  2718.    GLuint texSet = ctx->Texture.CurrentSet;
  2719.    GLuint texTransformSet = ctx->Texture.CurrentTransformSet;
  2720.    const struct gl_texture_set *textureSet = &ctx->Texture.Set[texSet];
  2721.  
  2722.    if (INSIDE_BEGIN_END(ctx)) {
  2723.       gl_error( ctx, GL_INVALID_OPERATION, "glGetIntegerv" );
  2724.       return;
  2725.    }
  2726.    switch (pname) {
  2727.       case GL_ACCUM_RED_BITS:
  2728.       case GL_ACCUM_GREEN_BITS:
  2729.       case GL_ACCUM_BLUE_BITS:
  2730.       case GL_ACCUM_ALPHA_BITS:
  2731.          *params = (GLint) ctx->Visual->AccumBits;
  2732.          break;
  2733.       case GL_ACCUM_CLEAR_VALUE:
  2734.          params[0] = FLOAT_TO_INT( ctx->Accum.ClearColor[0] );
  2735.          params[1] = FLOAT_TO_INT( ctx->Accum.ClearColor[1] );
  2736.          params[2] = FLOAT_TO_INT( ctx->Accum.ClearColor[2] );
  2737.          params[3] = FLOAT_TO_INT( ctx->Accum.ClearColor[3] );
  2738.          break;
  2739.       case GL_ALPHA_BIAS:
  2740.          *params = (GLint) ctx->Pixel.AlphaBias;
  2741.          break;
  2742.       case GL_ALPHA_BITS:
  2743.          *params = ctx->Visual->AlphaBits;
  2744.          break;
  2745.       case GL_ALPHA_SCALE:
  2746.          *params = (GLint) ctx->Pixel.AlphaScale;
  2747.          break;
  2748.       case GL_ALPHA_TEST:
  2749.          *params = (GLint) ctx->Color.AlphaEnabled;
  2750.          break;
  2751.       case GL_ALPHA_TEST_REF:
  2752.          *params = FLOAT_TO_INT( (GLfloat) ctx->Color.AlphaRef / 255.0 );
  2753.          break;
  2754.       case GL_ALPHA_TEST_FUNC:
  2755.          *params = (GLint) ctx->Color.AlphaFunc;
  2756.          break;
  2757.       case GL_ATTRIB_STACK_DEPTH:
  2758.          *params = (GLint) (ctx->AttribStackDepth);
  2759.          break;
  2760.       case GL_AUTO_NORMAL:
  2761.          *params = (GLint) ctx->Eval.AutoNormal;
  2762.          break;
  2763.       case GL_AUX_BUFFERS:
  2764.          *params = (GLint) NUM_AUX_BUFFERS;
  2765.          break;
  2766.       case GL_BLEND:
  2767.          *params = (GLint) ctx->Color.BlendEnabled;
  2768.          break;
  2769.       case GL_BLEND_DST:
  2770.          *params = (GLint) ctx->Color.BlendDst;
  2771.          break;
  2772.       case GL_BLEND_SRC:
  2773.          *params = (GLint) ctx->Color.BlendSrc;
  2774.          break;
  2775.       case GL_BLEND_EQUATION_EXT:
  2776.      *params = (GLint) ctx->Color.BlendEquation;
  2777.      break;
  2778.       case GL_BLEND_COLOR_EXT:
  2779.      params[0] = FLOAT_TO_INT( ctx->Color.BlendColor[0] );
  2780.      params[1] = FLOAT_TO_INT( ctx->Color.BlendColor[1] );
  2781.      params[2] = FLOAT_TO_INT( ctx->Color.BlendColor[2] );
  2782.      params[3] = FLOAT_TO_INT( ctx->Color.BlendColor[3] );
  2783.      break;
  2784.       case GL_BLUE_BIAS:
  2785.          *params = (GLint) ctx->Pixel.BlueBias;
  2786.          break;
  2787.       case GL_BLUE_BITS:
  2788.          *params = (GLint) ctx->Visual->BlueBits;
  2789.          break;
  2790.       case GL_BLUE_SCALE:
  2791.          *params = (GLint) ctx->Pixel.BlueScale;
  2792.          break;
  2793.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  2794.          *params = (GLint) (ctx->ClientAttribStackDepth);
  2795.          break;
  2796.       case GL_CLIP_PLANE0:
  2797.       case GL_CLIP_PLANE1:
  2798.       case GL_CLIP_PLANE2:
  2799.       case GL_CLIP_PLANE3:
  2800.       case GL_CLIP_PLANE4:
  2801.       case GL_CLIP_PLANE5:
  2802.          i = (GLint) (pname - GL_CLIP_PLANE0);
  2803.          *params = (GLint) ctx->Transform.ClipEnabled[i];
  2804.          break;
  2805.       case GL_COLOR_CLEAR_VALUE:
  2806.          params[0] = FLOAT_TO_INT( ctx->Color.ClearColor[0] );
  2807.          params[1] = FLOAT_TO_INT( ctx->Color.ClearColor[1] );
  2808.          params[2] = FLOAT_TO_INT( ctx->Color.ClearColor[2] );
  2809.          params[3] = FLOAT_TO_INT( ctx->Color.ClearColor[3] );
  2810.          break;
  2811.       case GL_COLOR_MATERIAL:
  2812.          *params = (GLint) ctx->Light.ColorMaterialEnabled;
  2813.          break;
  2814.       case GL_COLOR_MATERIAL_FACE:
  2815.          *params = (GLint) ctx->Light.ColorMaterialFace;
  2816.          break;
  2817.       case GL_COLOR_MATERIAL_PARAMETER:
  2818.          *params = (GLint) ctx->Light.ColorMaterialMode;
  2819.          break;
  2820.       case GL_COLOR_WRITEMASK:
  2821.          params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0;
  2822.          params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0;
  2823.          params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0;
  2824.          params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0;
  2825.          break;
  2826.       case GL_CULL_FACE:
  2827.          *params = (GLint) ctx->Polygon.CullFlag;
  2828.          break;
  2829.       case GL_CULL_FACE_MODE:
  2830.          *params = (GLint) ctx->Polygon.CullFaceMode;
  2831.          break;
  2832.       case GL_CURRENT_COLOR:
  2833.          params[0] = FLOAT_TO_INT( (GLfloat) ctx->Current.ByteColor[0] / 255.0F );
  2834.          params[1] = FLOAT_TO_INT( (GLfloat) ctx->Current.ByteColor[1] / 255.0F );
  2835.          params[2] = FLOAT_TO_INT( (GLfloat) ctx->Current.ByteColor[2] / 255.0F );
  2836.          params[3] = FLOAT_TO_INT( (GLfloat) ctx->Current.ByteColor[3] / 255.0F );
  2837.          break;
  2838.       case GL_CURRENT_INDEX:
  2839.          *params = (GLint) ctx->Current.Index;
  2840.          break;
  2841.       case GL_CURRENT_NORMAL:
  2842.          params[0] = FLOAT_TO_INT( ctx->Current.Normal[0] );
  2843.          params[1] = FLOAT_TO_INT( ctx->Current.Normal[1] );
  2844.          params[2] = FLOAT_TO_INT( ctx->Current.Normal[2] );
  2845.          break;
  2846.       case GL_CURRENT_RASTER_COLOR:
  2847.      params[0] = FLOAT_TO_INT( ctx->Current.RasterColor[0] );
  2848.      params[1] = FLOAT_TO_INT( ctx->Current.RasterColor[1] );
  2849.      params[2] = FLOAT_TO_INT( ctx->Current.RasterColor[2] );
  2850.      params[3] = FLOAT_TO_INT( ctx->Current.RasterColor[3] );
  2851.      break;
  2852.       case GL_CURRENT_RASTER_DISTANCE:
  2853.      params[0] = (GLint) ctx->Current.RasterDistance;
  2854.      break;
  2855.       case GL_CURRENT_RASTER_INDEX:
  2856.      *params = (GLint) ctx->Current.RasterIndex;
  2857.      break;
  2858.       case GL_CURRENT_RASTER_POSITION:
  2859.      params[0] = (GLint) ctx->Current.RasterPos[0];
  2860.      params[1] = (GLint) ctx->Current.RasterPos[1];
  2861.      params[2] = (GLint) ctx->Current.RasterPos[2];
  2862.      params[3] = (GLint) ctx->Current.RasterPos[3];
  2863.      break;
  2864.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  2865.      params[0] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformSet][0];
  2866.      params[1] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformSet][1];
  2867.      params[2] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformSet][2];
  2868.      params[3] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformSet][3];
  2869.      break;
  2870.       case GL_CURRENT_RASTER_POSITION_VALID:
  2871.      *params = (GLint) ctx->Current.RasterPosValid;
  2872.      break;
  2873.       case GL_CURRENT_TEXTURE_COORDS:
  2874.          params[0] = (GLint) ctx->Current.MultiTexCoord[texTransformSet][0];
  2875.          params[1] = (GLint) ctx->Current.MultiTexCoord[texTransformSet][1];
  2876.          params[2] = (GLint) ctx->Current.MultiTexCoord[texTransformSet][2];
  2877.          params[3] = (GLint) ctx->Current.MultiTexCoord[texTransformSet][3];
  2878.      break;
  2879.       case GL_DEPTH_BIAS:
  2880.          *params = (GLint) ctx->Pixel.DepthBias;
  2881.      break;
  2882.       case GL_DEPTH_BITS:
  2883.      *params = ctx->Visual->DepthBits;
  2884.      break;
  2885.       case GL_DEPTH_CLEAR_VALUE:
  2886.          *params = (GLint) ctx->Depth.Clear;
  2887.      break;
  2888.       case GL_DEPTH_FUNC:
  2889.          *params = (GLint) ctx->Depth.Func;
  2890.      break;
  2891.       case GL_DEPTH_RANGE:
  2892.          params[0] = (GLint) ctx->Viewport.Near;
  2893.          params[1] = (GLint) ctx->Viewport.Far;
  2894.      break;
  2895.       case GL_DEPTH_SCALE:
  2896.          *params = (GLint) ctx->Pixel.DepthScale;
  2897.      break;
  2898.       case GL_DEPTH_TEST:
  2899.          *params = (GLint) ctx->Depth.Test;
  2900.      break;
  2901.       case GL_DEPTH_WRITEMASK:
  2902.      *params = (GLint) ctx->Depth.Mask;
  2903.      break;
  2904.       case GL_DITHER:
  2905.      *params = (GLint) ctx->Color.DitherFlag;
  2906.      break;
  2907.       case GL_DOUBLEBUFFER:
  2908.      *params = (GLint) ctx->Visual->DBflag;
  2909.      break;
  2910.       case GL_DRAW_BUFFER:
  2911.      *params = (GLint) ctx->Color.DrawBuffer;
  2912.      break;
  2913.       case GL_EDGE_FLAG:
  2914.      *params = (GLint) ctx->Current.EdgeFlag;
  2915.      break;
  2916.       case GL_FEEDBACK_BUFFER_SIZE:
  2917.          /* TODO: is this right?  Or, return number of entries in buffer? */
  2918.          *params = ctx->Feedback.BufferSize;
  2919.          break;
  2920.       case GL_FEEDBACK_BUFFER_TYPE:
  2921.          *params = ctx->Feedback.Type;
  2922.          break;
  2923.       case GL_FOG:
  2924.      *params = (GLint) ctx->Fog.Enabled;
  2925.      break;
  2926.       case GL_FOG_COLOR:
  2927.      params[0] = FLOAT_TO_INT( ctx->Fog.Color[0] );
  2928.      params[1] = FLOAT_TO_INT( ctx->Fog.Color[1] );
  2929.      params[2] = FLOAT_TO_INT( ctx->Fog.Color[2] );
  2930.      params[3] = FLOAT_TO_INT( ctx->Fog.Color[3] );
  2931.      break;
  2932.       case GL_FOG_DENSITY:
  2933.      *params = (GLint) ctx->Fog.Density;
  2934.      break;
  2935.       case GL_FOG_END:
  2936.      *params = (GLint) ctx->Fog.End;
  2937.      break;
  2938.       case GL_FOG_HINT:
  2939.      *params = (GLint) ctx->Hint.Fog;
  2940.      break;
  2941.       case GL_FOG_INDEX:
  2942.      *params = (GLint) ctx->Fog.Index;
  2943.      break;
  2944.       case GL_FOG_MODE:
  2945.      *params = (GLint) ctx->Fog.Mode;
  2946.      break;
  2947.       case GL_FOG_START:
  2948.      *params = (GLint) ctx->Fog.Start;
  2949.      break;
  2950.       case GL_FRONT_FACE:
  2951.      *params = (GLint) ctx->Polygon.FrontFace;
  2952.      break;
  2953.       case GL_GREEN_BIAS:
  2954.          *params = (GLint) ctx->Pixel.GreenBias;
  2955.          break;
  2956.       case GL_GREEN_BITS:
  2957.          *params = (GLint) ctx->Visual->GreenBits;
  2958.          break;
  2959.       case GL_GREEN_SCALE:
  2960.          *params = (GLint) ctx->Pixel.GreenScale;
  2961.          break;
  2962.       case GL_INDEX_BITS:
  2963.          *params = (GLint) ctx->Visual->IndexBits;
  2964.          break;
  2965.       case GL_INDEX_CLEAR_VALUE:
  2966.          *params = (GLint) ctx->Color.ClearIndex;
  2967.          break;
  2968.       case GL_INDEX_MODE:
  2969.      *params = ctx->Visual->RGBAflag ? 0 : 1;
  2970.      break;
  2971.       case GL_INDEX_OFFSET:
  2972.      *params = ctx->Pixel.IndexOffset;
  2973.      break;
  2974.       case GL_INDEX_SHIFT:
  2975.      *params = ctx->Pixel.IndexShift;
  2976.      break;
  2977.       case GL_INDEX_WRITEMASK:
  2978.      *params = (GLint) ctx->Color.IndexMask;
  2979.      break;
  2980.       case GL_LIGHT0:
  2981.       case GL_LIGHT1:
  2982.       case GL_LIGHT2:
  2983.       case GL_LIGHT3:
  2984.       case GL_LIGHT4:
  2985.       case GL_LIGHT5:
  2986.       case GL_LIGHT6:
  2987.       case GL_LIGHT7:
  2988.      *params = (GLint) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  2989.      break;
  2990.       case GL_LIGHTING:
  2991.      *params = (GLint) ctx->Light.Enabled;
  2992.      break;
  2993.       case GL_LIGHT_MODEL_AMBIENT:
  2994.      params[0] = FLOAT_TO_INT( ctx->Light.Model.Ambient[0] );
  2995.      params[1] = FLOAT_TO_INT( ctx->Light.Model.Ambient[1] );
  2996.      params[2] = FLOAT_TO_INT( ctx->Light.Model.Ambient[2] );
  2997.      params[3] = FLOAT_TO_INT( ctx->Light.Model.Ambient[3] );
  2998.      break;
  2999.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  3000.          params[0] = (GLint) ctx->Light.Model.ColorControl;
  3001.          break;
  3002.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  3003.      *params = (GLint) ctx->Light.Model.LocalViewer;
  3004.      break;
  3005.       case GL_LIGHT_MODEL_TWO_SIDE:
  3006.      *params = (GLint) ctx->Light.Model.TwoSide;
  3007.      break;
  3008.       case GL_LINE_SMOOTH:
  3009.      *params = (GLint) ctx->Line.SmoothFlag;
  3010.      break;
  3011.       case GL_LINE_SMOOTH_HINT:
  3012.      *params = (GLint) ctx->Hint.LineSmooth;
  3013.      break;
  3014.       case GL_LINE_STIPPLE:
  3015.      *params = (GLint) ctx->Line.StippleFlag;
  3016.      break;
  3017.       case GL_LINE_STIPPLE_PATTERN:
  3018.          *params = (GLint) ctx->Line.StipplePattern;
  3019.          break;
  3020.       case GL_LINE_STIPPLE_REPEAT:
  3021.          *params = (GLint) ctx->Line.StippleFactor;
  3022.          break;
  3023.       case GL_LINE_WIDTH:
  3024.      *params = (GLint) ctx->Line.Width;
  3025.      break;
  3026.       case GL_LINE_WIDTH_GRANULARITY:
  3027.      *params = (GLint) LINE_WIDTH_GRANULARITY;
  3028.      break;
  3029.       case GL_LINE_WIDTH_RANGE:
  3030.      params[0] = (GLint) MIN_LINE_WIDTH;
  3031.      params[1] = (GLint) MAX_LINE_WIDTH;
  3032.      break;
  3033.       case GL_LIST_BASE:
  3034.      *params = (GLint) ctx->List.ListBase;
  3035.      break;
  3036.       case GL_LIST_INDEX:
  3037.      *params = (GLint) ctx->CurrentListNum;
  3038.      break;
  3039.       case GL_LIST_MODE:
  3040.      *params = ctx->ExecuteFlag ? (GLint) GL_COMPILE_AND_EXECUTE
  3041.                      : (GLint) GL_COMPILE;
  3042.      break;
  3043.       case GL_INDEX_LOGIC_OP:
  3044.      *params = (GLint) ctx->Color.IndexLogicOpEnabled;
  3045.      break;
  3046.       case GL_COLOR_LOGIC_OP:
  3047.      *params = (GLint) ctx->Color.ColorLogicOpEnabled;
  3048.      break;
  3049.       case GL_LOGIC_OP_MODE:
  3050.          *params = (GLint) ctx->Color.LogicOp;
  3051.          break;
  3052.       case GL_MAP1_COLOR_4:
  3053.      *params = (GLint) ctx->Eval.Map1Color4;
  3054.      break;
  3055.       case GL_MAP1_GRID_DOMAIN:
  3056.      params[0] = (GLint) ctx->Eval.MapGrid1u1;
  3057.      params[1] = (GLint) ctx->Eval.MapGrid1u2;
  3058.      break;
  3059.       case GL_MAP1_GRID_SEGMENTS:
  3060.      *params = (GLint) ctx->Eval.MapGrid1un;
  3061.      break;
  3062.       case GL_MAP1_INDEX:
  3063.      *params = (GLint) ctx->Eval.Map1Index;
  3064.      break;
  3065.       case GL_MAP1_NORMAL:
  3066.      *params = (GLint) ctx->Eval.Map1Normal;
  3067.      break;
  3068.       case GL_MAP1_TEXTURE_COORD_1:
  3069.      *params = (GLint) ctx->Eval.Map1TextureCoord1;
  3070.      break;
  3071.       case GL_MAP1_TEXTURE_COORD_2:
  3072.      *params = (GLint) ctx->Eval.Map1TextureCoord2;
  3073.      break;
  3074.       case GL_MAP1_TEXTURE_COORD_3:
  3075.      *params = (GLint) ctx->Eval.Map1TextureCoord3;
  3076.      break;
  3077.       case GL_MAP1_TEXTURE_COORD_4:
  3078.      *params = (GLint) ctx->Eval.Map1TextureCoord4;
  3079.      break;
  3080.       case GL_MAP1_VERTEX_3:
  3081.      *params = (GLint) ctx->Eval.Map1Vertex3;
  3082.      break;
  3083.       case GL_MAP1_VERTEX_4:
  3084.      *params = (GLint) ctx->Eval.Map1Vertex4;
  3085.      break;
  3086.       case GL_MAP2_COLOR_4:
  3087.      *params = (GLint) ctx->Eval.Map2Color4;
  3088.      break;
  3089.       case GL_MAP2_GRID_DOMAIN:
  3090.      params[0] = (GLint) ctx->Eval.MapGrid2u1;
  3091.      params[1] = (GLint) ctx->Eval.MapGrid2u2;
  3092.      params[2] = (GLint) ctx->Eval.MapGrid2v1;
  3093.      params[3] = (GLint) ctx->Eval.MapGrid2v2;
  3094.      break;
  3095.       case GL_MAP2_GRID_SEGMENTS:
  3096.      params[0] = (GLint) ctx->Eval.MapGrid2un;
  3097.      params[1] = (GLint) ctx->Eval.MapGrid2vn;
  3098.      break;
  3099.       case GL_MAP2_INDEX:
  3100.      *params = (GLint) ctx->Eval.Map2Index;
  3101.      break;
  3102.       case GL_MAP2_NORMAL:
  3103.      *params = (GLint) ctx->Eval.Map2Normal;
  3104.      break;
  3105.       case GL_MAP2_TEXTURE_COORD_1:
  3106.      *params = (GLint) ctx->Eval.Map2TextureCoord1;
  3107.      break;
  3108.       case GL_MAP2_TEXTURE_COORD_2:
  3109.      *params = (GLint) ctx->Eval.Map2TextureCoord2;
  3110.      break;
  3111.       case GL_MAP2_TEXTURE_COORD_3:
  3112.      *params = (GLint) ctx->Eval.Map2TextureCoord3;
  3113.      break;
  3114.       case GL_MAP2_TEXTURE_COORD_4:
  3115.      *params = (GLint) ctx->Eval.Map2TextureCoord4;
  3116.      break;
  3117.       case GL_MAP2_VERTEX_3:
  3118.      *params = (GLint) ctx->Eval.Map2Vertex3;
  3119.      break;
  3120.       case GL_MAP2_VERTEX_4:
  3121.      *params = (GLint) ctx->Eval.Map2Vertex4;
  3122.      break;
  3123.       case GL_MAP_COLOR:
  3124.      *params = (GLint) ctx->Pixel.MapColorFlag;
  3125.      break;
  3126.       case GL_MAP_STENCIL:
  3127.      *params = (GLint) ctx->Pixel.MapStencilFlag;
  3128.      break;
  3129.       case GL_MATRIX_MODE:
  3130.      *params = (GLint) ctx->Transform.MatrixMode;
  3131.      break;
  3132.       case GL_MAX_ATTRIB_STACK_DEPTH:
  3133.          *params = (GLint) MAX_ATTRIB_STACK_DEPTH;
  3134.          break;
  3135.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  3136.          *params = (GLint) MAX_CLIENT_ATTRIB_STACK_DEPTH;
  3137.          break;
  3138.       case GL_MAX_CLIP_PLANES:
  3139.          *params = (GLint) MAX_CLIP_PLANES;
  3140.          break;
  3141.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  3142.          *params = VB_MAX;
  3143.          break;
  3144.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  3145.          *params = VB_MAX;
  3146.          break;
  3147.       case GL_MAX_EVAL_ORDER:
  3148.      *params = (GLint) MAX_EVAL_ORDER;
  3149.      break;
  3150.       case GL_MAX_LIGHTS:
  3151.          *params = (GLint) MAX_LIGHTS;
  3152.          break;
  3153.       case GL_MAX_LIST_NESTING:
  3154.          *params = (GLint) MAX_LIST_NESTING;
  3155.          break;
  3156.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  3157.          *params = (GLint) MAX_MODELVIEW_STACK_DEPTH;
  3158.          break;
  3159.       case GL_MAX_NAME_STACK_DEPTH:
  3160.      *params = (GLint) MAX_NAME_STACK_DEPTH;
  3161.      break;
  3162.       case GL_MAX_PIXEL_MAP_TABLE:
  3163.      *params = (GLint) MAX_PIXEL_MAP_TABLE;
  3164.      break;
  3165.       case GL_MAX_PROJECTION_STACK_DEPTH:
  3166.          *params = (GLint) MAX_PROJECTION_STACK_DEPTH;
  3167.          break;
  3168.       case GL_MAX_TEXTURE_SIZE:
  3169.       case GL_MAX_3D_TEXTURE_SIZE:
  3170.          *params = max_texture_size(ctx);
  3171.      break;
  3172.       case GL_MAX_TEXTURE_STACK_DEPTH:
  3173.      *params = (GLint) MAX_TEXTURE_STACK_DEPTH;
  3174.      break;
  3175.       case GL_MAX_VIEWPORT_DIMS:
  3176.          params[0] = (GLint) MAX_WIDTH;
  3177.          params[1] = (GLint) MAX_HEIGHT;
  3178.          break;
  3179.       case GL_MODELVIEW_MATRIX:
  3180.      for (i=0;i<16;i++) {
  3181.         params[i] = (GLint) ctx->ModelViewMatrix[i];
  3182.      }
  3183.      break;
  3184.       case GL_MODELVIEW_STACK_DEPTH:
  3185.      *params = (GLint) (ctx->ModelViewStackDepth + 1);
  3186.      break;
  3187.       case GL_NAME_STACK_DEPTH:
  3188.      *params = (GLint) ctx->Select.NameStackDepth;
  3189.      break;
  3190.       case GL_NORMALIZE:
  3191.      *params = (GLint) ctx->Transform.Normalize;
  3192.      break;
  3193.       case GL_PACK_ALIGNMENT:
  3194.      *params = ctx->Pack.Alignment;
  3195.      break;
  3196.       case GL_PACK_LSB_FIRST:
  3197.      *params = (GLint) ctx->Pack.LsbFirst;
  3198.      break;
  3199.       case GL_PACK_ROW_LENGTH:
  3200.      *params = ctx->Pack.RowLength;
  3201.      break;
  3202.       case GL_PACK_SKIP_PIXELS:
  3203.      *params = ctx->Pack.SkipPixels;
  3204.      break;
  3205.       case GL_PACK_SKIP_ROWS:
  3206.      *params = ctx->Pack.SkipRows;
  3207.      break;
  3208.       case GL_PACK_SWAP_BYTES:
  3209.      *params = (GLint) ctx->Pack.SwapBytes;
  3210.      break;
  3211.       case GL_PACK_SKIP_IMAGES_EXT:
  3212.          *params = ctx->Pack.SkipImages;
  3213.          break;
  3214.       case GL_PACK_IMAGE_HEIGHT_EXT:
  3215.          *params = ctx->Pack.ImageHeight;
  3216.          break;
  3217.       case GL_PERSPECTIVE_CORRECTION_HINT:
  3218.      *params = (GLint) ctx->Hint.PerspectiveCorrection;
  3219.      break;
  3220.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  3221.      *params = ctx->Pixel.MapAtoAsize;
  3222.      break;
  3223.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  3224.      *params = ctx->Pixel.MapBtoBsize;
  3225.      break;
  3226.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  3227.      *params = ctx->Pixel.MapGtoGsize;
  3228.      break;
  3229.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  3230.      *params = ctx->Pixel.MapItoAsize;
  3231.      break;
  3232.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  3233.      *params = ctx->Pixel.MapItoBsize;
  3234.      break;
  3235.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  3236.      *params = ctx->Pixel.MapItoGsize;
  3237.      break;
  3238.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  3239.      *params = ctx->Pixel.MapItoIsize;
  3240.      break;
  3241.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  3242.      *params = ctx->Pixel.MapItoRsize;
  3243.      break;
  3244.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  3245.      *params = ctx->Pixel.MapRtoRsize;
  3246.      break;
  3247.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  3248.      *params = ctx->Pixel.MapStoSsize;
  3249.      break;
  3250.       case GL_POINT_SIZE:
  3251.          *params = (GLint) ctx->Point.Size;
  3252.          break;
  3253.       case GL_POINT_SIZE_GRANULARITY:
  3254.      *params = (GLint) POINT_SIZE_GRANULARITY;
  3255.      break;
  3256.       case GL_POINT_SIZE_RANGE:
  3257.      params[0] = (GLint) MIN_POINT_SIZE;
  3258.      params[1] = (GLint) MAX_POINT_SIZE;
  3259.      break;
  3260.       case GL_POINT_SMOOTH:
  3261.      *params = (GLint) ctx->Point.SmoothFlag;
  3262.      break;
  3263.       case GL_POINT_SMOOTH_HINT:
  3264.      *params = (GLint) ctx->Hint.PointSmooth;
  3265.      break;
  3266.       case GL_POINT_SIZE_MIN_EXT:
  3267.      *params = (GLint) (ctx->Point.MinSize);
  3268.      break;
  3269.       case GL_POINT_SIZE_MAX_EXT:
  3270.      *params = (GLint) (ctx->Point.MaxSize);
  3271.      break;
  3272.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  3273.      *params = (GLint) (ctx->Point.Threshold);
  3274.      break;
  3275.       case GL_DISTANCE_ATTENUATION_EXT:
  3276.      params[0] = (GLint) (ctx->Point.Params[0]);
  3277.      params[1] = (GLint) (ctx->Point.Params[1]);
  3278.      params[2] = (GLint) (ctx->Point.Params[2]);
  3279.      break;
  3280.       case GL_POLYGON_MODE:
  3281.      params[0] = (GLint) ctx->Polygon.FrontMode;
  3282.      params[1] = (GLint) ctx->Polygon.BackMode;
  3283.      break;
  3284. #ifdef GL_EXT_polygon_offset
  3285.       case GL_POLYGON_OFFSET_BIAS_EXT:
  3286.          *params = (GLint) ctx->Polygon.OffsetUnits;
  3287.          break;
  3288. #endif
  3289.       case GL_POLYGON_OFFSET_FACTOR:
  3290.          *params = (GLint) ctx->Polygon.OffsetFactor;
  3291.          break;
  3292.       case GL_POLYGON_OFFSET_UNITS:
  3293.          *params = (GLint) ctx->Polygon.OffsetUnits;
  3294.          break;
  3295.       case GL_POLYGON_SMOOTH:
  3296.      *params = (GLint) ctx->Polygon.SmoothFlag;
  3297.      break;
  3298.       case GL_POLYGON_SMOOTH_HINT:
  3299.      *params = (GLint) ctx->Hint.PolygonSmooth;
  3300.      break;
  3301.       case GL_POLYGON_STIPPLE:
  3302.          *params = (GLint) ctx->Polygon.StippleFlag;
  3303.      break;
  3304.       case GL_PROJECTION_MATRIX:
  3305.      for (i=0;i<16;i++) {
  3306.         params[i] = (GLint) ctx->ProjectionMatrix[i];
  3307.      }
  3308.      break;
  3309.       case GL_PROJECTION_STACK_DEPTH:
  3310.      *params = (GLint) (ctx->ProjectionStackDepth + 1);
  3311.      break;
  3312.       case GL_READ_BUFFER:
  3313.      *params = (GLint) ctx->Pixel.ReadBuffer;
  3314.      break;
  3315.       case GL_RED_BIAS:
  3316.          *params = (GLint) ctx->Pixel.RedBias;
  3317.          break;
  3318.       case GL_RED_BITS:
  3319.          *params = (GLint) ctx->Visual->RedBits;
  3320.          break;
  3321.       case GL_RED_SCALE:
  3322.          *params = (GLint) ctx->Pixel.RedScale;
  3323.          break;
  3324.       case GL_RENDER_MODE:
  3325.      *params = (GLint) ctx->RenderMode;
  3326.      break;
  3327.       case GL_RGBA_MODE:
  3328.      *params = (GLint) ctx->Visual->RGBAflag;
  3329.      break;
  3330.       case GL_SCISSOR_BOX:
  3331.      params[0] = (GLint) ctx->Scissor.X;
  3332.      params[1] = (GLint) ctx->Scissor.Y;
  3333.      params[2] = (GLint) ctx->Scissor.Width;
  3334.      params[3] = (GLint) ctx->Scissor.Height;
  3335.      break;
  3336.       case GL_SCISSOR_TEST:
  3337.      *params = (GLint) ctx->Scissor.Enabled;
  3338.      break;
  3339.       case GL_SELECTION_BUFFER_SIZE:
  3340.          *params = (GLint) ctx->Select.BufferSize;
  3341.          break;
  3342.       case GL_SHADE_MODEL:
  3343.      *params = (GLint) ctx->Light.ShadeModel;
  3344.      break;
  3345.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  3346.          *params = (GLint) ctx->Texture.SharedPalette;
  3347.          break;
  3348.       case GL_STENCIL_BITS:
  3349.          *params = ctx->Visual->StencilBits;
  3350.          break;
  3351.       case GL_STENCIL_CLEAR_VALUE:
  3352.      *params = (GLint) ctx->Stencil.Clear;
  3353.      break;
  3354.       case GL_STENCIL_FAIL:
  3355.      *params = (GLint) ctx->Stencil.FailFunc;
  3356.      break;
  3357.       case GL_STENCIL_FUNC:
  3358.      *params = (GLint) ctx->Stencil.Function;
  3359.      break;
  3360.       case GL_STENCIL_PASS_DEPTH_FAIL:
  3361.      *params = (GLint) ctx->Stencil.ZFailFunc;
  3362.      break;
  3363.       case GL_STENCIL_PASS_DEPTH_PASS:
  3364.      *params = (GLint) ctx->Stencil.ZPassFunc;
  3365.      break;
  3366.       case GL_STENCIL_REF:
  3367.      *params = (GLint) ctx->Stencil.Ref;
  3368.      break;
  3369.       case GL_STENCIL_TEST:
  3370.      *params = (GLint) ctx->Stencil.Enabled;
  3371.      break;
  3372.       case GL_STENCIL_VALUE_MASK:
  3373.      *params = (GLint) ctx->Stencil.ValueMask;
  3374.      break;
  3375.       case GL_STENCIL_WRITEMASK:
  3376.      *params = (GLint) ctx->Stencil.WriteMask;
  3377.      break;
  3378.       case GL_STEREO:
  3379.      *params = 0;  /* TODO */
  3380.      break;
  3381.       case GL_SUBPIXEL_BITS:
  3382.      *params = 0;  /* TODO */
  3383.      break;
  3384.       case GL_TEXTURE_1D:
  3385.          {
  3386.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  3387.             *params = (ctx->Texture.Enabled & bit) ? 1 : 0;
  3388.          }
  3389.      break;
  3390.       case GL_TEXTURE_2D:
  3391.          {
  3392.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  3393.             *params = (ctx->Texture.Enabled & bit) ? 1 : 0;
  3394.          }
  3395.      break;
  3396.       case GL_TEXTURE_3D:
  3397.          {
  3398.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  3399.             *params = (ctx->Texture.Enabled & bit) ? 1 : 0;
  3400.          }
  3401.      break;
  3402.       case GL_TEXTURE_BINDING_1D:
  3403.          *params = textureSet->Current1D->Name;
  3404.           break;
  3405.       case GL_TEXTURE_BINDING_2D:
  3406.          *params = textureSet->Current2D->Name;
  3407.           break;
  3408.       case GL_TEXTURE_BINDING_3D:
  3409.          *params = textureSet->Current3D->Name;
  3410.           break;
  3411.       case GL_TEXTURE_ENV_COLOR:
  3412.      params[0] = FLOAT_TO_INT( textureSet->EnvColor[0] );
  3413.      params[1] = FLOAT_TO_INT( textureSet->EnvColor[1] );
  3414.      params[2] = FLOAT_TO_INT( textureSet->EnvColor[2] );
  3415.      params[3] = FLOAT_TO_INT( textureSet->EnvColor[3] );
  3416.      break;
  3417.       case GL_TEXTURE_ENV_MODE:
  3418.      *params = (GLint) textureSet->EnvMode;
  3419.      break;
  3420.       case GL_TEXTURE_GEN_S:
  3421.      *params = (textureSet->TexGenEnabled & S_BIT) ? 1 : 0;
  3422.      break;
  3423.       case GL_TEXTURE_GEN_T:
  3424.      *params = (textureSet->TexGenEnabled & T_BIT) ? 1 : 0;
  3425.      break;
  3426.       case GL_TEXTURE_GEN_R:
  3427.      *params = (textureSet->TexGenEnabled & R_BIT) ? 1 : 0;
  3428.      break;
  3429.       case GL_TEXTURE_GEN_Q:
  3430.      *params = (textureSet->TexGenEnabled & Q_BIT) ? 1 : 0;
  3431.      break;
  3432.       case GL_TEXTURE_MATRIX:
  3433.          for (i=0;i<16;i++) {
  3434.         params[i] = (GLint) ctx->TextureMatrix[texTransformSet][i];
  3435.      }
  3436.      break;
  3437.       case GL_TEXTURE_STACK_DEPTH:
  3438.      *params = (GLint) (ctx->TextureStackDepth[texTransformSet] + 1);
  3439.      break;
  3440.       case GL_UNPACK_ALIGNMENT:
  3441.      *params = ctx->Unpack.Alignment;
  3442.      break;
  3443.       case GL_UNPACK_LSB_FIRST:
  3444.      *params = (GLint) ctx->Unpack.LsbFirst;
  3445.      break;
  3446.       case GL_UNPACK_ROW_LENGTH:
  3447.      *params = ctx->Unpack.RowLength;
  3448.      break;
  3449.       case GL_UNPACK_SKIP_PIXELS:
  3450.      *params = ctx->Unpack.SkipPixels;
  3451.      break;
  3452.       case GL_UNPACK_SKIP_ROWS:
  3453.      *params = ctx->Unpack.SkipRows;
  3454.      break;
  3455.       case GL_UNPACK_SWAP_BYTES:
  3456.      *params = (GLint) ctx->Unpack.SwapBytes;
  3457.      break;
  3458.       case GL_UNPACK_SKIP_IMAGES_EXT:
  3459.          *params = ctx->Unpack.SkipImages;
  3460.          break;
  3461.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  3462.          *params = ctx->Unpack.ImageHeight;
  3463.          break;
  3464.       case GL_VIEWPORT:
  3465.          params[0] = (GLint) ctx->Viewport.X;
  3466.          params[1] = (GLint) ctx->Viewport.Y;
  3467.          params[2] = (GLint) ctx->Viewport.Width;
  3468.          params[3] = (GLint) ctx->Viewport.Height;
  3469.          break;
  3470.       case GL_ZOOM_X:
  3471.      *params = (GLint) ctx->Pixel.ZoomX;
  3472.      break;
  3473.       case GL_ZOOM_Y:
  3474.      *params = (GLint) ctx->Pixel.ZoomY;
  3475.      break;
  3476.       case GL_VERTEX_ARRAY_SIZE:
  3477.          *params = ctx->Array.VertexSize;
  3478.          break;
  3479.       case GL_VERTEX_ARRAY_TYPE:
  3480.          *params = ctx->Array.VertexType;
  3481.          break;
  3482.       case GL_VERTEX_ARRAY_STRIDE:
  3483.          *params = ctx->Array.VertexStride;
  3484.          break;
  3485.       case GL_VERTEX_ARRAY_COUNT_EXT:
  3486.          *params = 0;
  3487.          break;
  3488.       case GL_NORMAL_ARRAY_TYPE:
  3489.          *params = ctx->Array.NormalType;
  3490.          break;
  3491.       case GL_NORMAL_ARRAY_STRIDE:
  3492.          *params = ctx->Array.NormalStride;
  3493.          break;
  3494.       case GL_NORMAL_ARRAY_COUNT_EXT:
  3495.          *params = 0;
  3496.          break;
  3497.       case GL_COLOR_ARRAY_SIZE:
  3498.          *params = ctx->Array.ColorSize;
  3499.          break;
  3500.       case GL_COLOR_ARRAY_TYPE:
  3501.          *params = ctx->Array.ColorType;
  3502.          break;
  3503.       case GL_COLOR_ARRAY_STRIDE:
  3504.          *params = ctx->Array.ColorStride;
  3505.          break;
  3506.       case GL_COLOR_ARRAY_COUNT_EXT:
  3507.          *params = 0;
  3508.          break;
  3509.       case GL_INDEX_ARRAY_TYPE:
  3510.          *params = ctx->Array.IndexType;
  3511.          break;
  3512.       case GL_INDEX_ARRAY_STRIDE:
  3513.          *params = ctx->Array.IndexStride;
  3514.          break;
  3515.       case GL_INDEX_ARRAY_COUNT_EXT:
  3516.          *params = 0;
  3517.          break;
  3518.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  3519.          *params = ctx->Array.TexCoordSize[texSet];
  3520.          break;
  3521.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  3522.          *params = ctx->Array.TexCoordType[texSet];
  3523.          break;
  3524.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  3525.          *params = ctx->Array.TexCoordStride[texSet];
  3526.          break;
  3527.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  3528.          *params = 0;
  3529.          break;
  3530.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  3531.          *params = ctx->Array.EdgeFlagStride;
  3532.          break;
  3533.       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
  3534.          *params = 0;
  3535.          break;
  3536.  
  3537.       /* GL_SGIS_multitexture */
  3538.       case GL_SELECTED_TEXTURE_SGIS:
  3539.          *params = ctx->Texture.CurrentSet;
  3540.          break;
  3541.       case GL_SELECTED_TEXTURE_COORD_SET_SGIS:
  3542.          *params = ctx->TexCoordSet;
  3543.          break;
  3544.       case GL_MAX_TEXTURES_SGIS:
  3545.          *params = max_textures(ctx);
  3546.          break;
  3547.  
  3548.       /* GL_EXT_multitexture */
  3549.       case GL_SELECTED_TEXTURE_EXT:
  3550.          *params = ctx->Texture.CurrentSet;
  3551.          break;
  3552.       case GL_SELECTED_TEXTURE_COORD_SET_EXT:
  3553.          *params = ctx->TexCoordSet;
  3554.          break;
  3555.       case GL_SELECTED_TEXTURE_TRANSFORM_EXT:
  3556.          *params = ctx->Texture.CurrentTransformSet;
  3557.          break;
  3558.       case GL_MAX_TEXTURES_EXT:
  3559.          *params = max_textures(ctx);
  3560.          break;
  3561.       case GL_MAX_TEXTURE_COORD_SETS_EXT:
  3562.          *params = MAX_TEX_COORD_SETS;
  3563.          break;
  3564.  
  3565.       default:
  3566.          gl_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
  3567.    }
  3568. }
  3569.  
  3570.  
  3571.  
  3572. void gl_GetPointerv( GLcontext *ctx, GLenum pname, GLvoid **params )
  3573. {
  3574.    GLuint texSet = ctx->Texture.CurrentSet;
  3575.    /*GLuint texTransformSet = ctx->Texture.CurrentTransformSet;*/
  3576.    switch (pname) {
  3577.       case GL_VERTEX_ARRAY_POINTER:
  3578.          *params = ctx->Array.VertexPtr;
  3579.          break;
  3580.       case GL_NORMAL_ARRAY_POINTER:
  3581.          *params = ctx->Array.NormalPtr;
  3582.          break;
  3583.       case GL_COLOR_ARRAY_POINTER:
  3584.          *params = ctx->Array.ColorPtr;
  3585.          break;
  3586.       case GL_INDEX_ARRAY_POINTER:
  3587.          *params = ctx->Array.IndexPtr;
  3588.          break;
  3589.       case GL_TEXTURE_COORD_ARRAY_POINTER:
  3590.          *params = ctx->Array.TexCoordPtr[texSet];
  3591.          break;
  3592.       case GL_EDGE_FLAG_ARRAY_POINTER:
  3593.          *params = ctx->Array.EdgeFlagPtr;
  3594.          break;
  3595.       case GL_FEEDBACK_BUFFER_POINTER:
  3596.          *params = ctx->Feedback.Buffer;
  3597.          break;
  3598.       case GL_SELECTION_BUFFER_POINTER:
  3599.          *params = ctx->Select.Buffer;
  3600.          break;
  3601.       default:
  3602.          gl_error( ctx, GL_INVALID_ENUM, "glGetPointerv" );
  3603.          return;
  3604.    }
  3605. }
  3606.